diff --git a/src/composables/__tests__/useDashboardSuggestions.spec.ts b/src/composables/__tests__/useDashboardSuggestions.spec.ts
new file mode 100644
index 00000000..ab46decb
--- /dev/null
+++ b/src/composables/__tests__/useDashboardSuggestions.spec.ts
@@ -0,0 +1,95 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { effectScope, ref } from 'vue';
+
+const mocks = vi.hoisted(() => ({
+  execute: vi.fn(),
+  toastAdd: vi.fn(),
+}));
+
+vi.mock('@/composables/axios', () => ({
+  useDataApi: () => ({
+    execute: mocks.execute,
+    isLoading: { value: false },
+    error: { value: null },
+  }),
+  decamelizeKeys: vi.fn((data: unknown) => JSON.stringify(data)),
+}));
+
+vi.mock('primevue/usetoast', () => ({
+  useToast: () => ({ add: mocks.toastAdd }),
+}));
+
+import { useSuggestionRunPoller } from '../useDashboardSuggestions';
+
+function response(status: string, completedCells: number, id = status) {
+  return {
+    data: {
+      value: {
+        data: {
+          id,
+          status,
+          plannedCalls: 2,
+          completedCells,
+          failedCells: 0,
+        },
+      },
+    },
+  };
+}
+
+describe('useSuggestionRunPoller', () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it('starts polling active runs, stops on terminal status, and fires toast', async () => {
+    const onPoll = vi.fn();
+    mocks.execute
+      .mockResolvedValueOnce(response('running', 1, 'run-1'))
+      .mockResolvedValueOnce(response('completed', 2, 'run-1'));
+
+    const scope = effectScope();
+    const poller = scope.run(() =>
+      useSuggestionRunPoller(ref('ssp-1'), onPoll),
+    );
+
+    await poller?.pollLatest();
+    expect(poller?.isPolling.value).toBe(true);
+
+    await vi.advanceTimersByTimeAsync(3000);
+
+    expect(mocks.execute).toHaveBeenCalledTimes(2);
+    expect(onPoll).toHaveBeenCalledTimes(2);
+    expect(poller?.isPolling.value).toBe(false);
+    expect(mocks.toastAdd).toHaveBeenCalledWith(
+      expect.objectContaining({
+        severity: 'success',
+        summary: 'Suggestions ready',
+      }),
+    );
+
+    scope.stop();
+  });
+
+  it('keeps polling after a transient poll error', async () => {
+    mocks.execute
+      .mockRejectedValueOnce(new Error('temporary outage'))
+      .mockResolvedValueOnce(response('completed', 2, 'run-1'));
+
+    const scope = effectScope();
+    const poller = scope.run(() => useSuggestionRunPoller(ref('ssp-1')));
+
+    poller?.start();
+    await vi.advanceTimersByTimeAsync(3000);
+    await vi.advanceTimersByTimeAsync(3000);
+
+    expect(mocks.execute).toHaveBeenCalledTimes(2);
+
+    scope.stop();
+  });
+});
diff --git a/src/composables/axios/index.ts b/src/composables/axios/index.ts
index 21db1cf0..756bcdad 100644
--- a/src/composables/axios/index.ts
+++ b/src/composables/axios/index.ts
@@ -14,6 +14,15 @@ import { useAxios } from '@vueuse/integrations/useAxios';
 import camelcaseKeys from 'camelcase-keys';
 import { default as _decamelizeKeys } from 'decamelize-keys';
 
+declare module 'axios' {
+  interface AxiosRequestConfig {
+    // Object paths whose child keys should be left untouched by the response
+    // camelcase conversion (e.g. arbitrary label maps that may use snake_case
+    // or `_`-prefixed keys we need to preserve verbatim).
+    camelcaseStopPaths?: readonly string[];
+  }
+}
+
 const useAuthenticatedInstance = () => {
   const userStore = useUserStore();
   const configStore = useConfigStore();
@@ -62,7 +71,11 @@ const useAuthenticatedInstance = () => {
       // Brute force camelcase conversion. OSCAL apis are all kebab-case so should be converted to
       // camel case, but any manually written APIs will be camel case and therefore won't change
       if (response.data) {
-        response.data = camelcaseKeys(response.data, { deep: true });
+        const stopPaths = response.config?.camelcaseStopPaths;
+        response.data = camelcaseKeys(response.data, {
+          deep: true,
+          ...(stopPaths ? { stopPaths: [...stopPaths] } : {}),
+        });
       }
       return response;
     },
diff --git a/src/composables/useDashboardSuggestions.ts b/src/composables/useDashboardSuggestions.ts
new file mode 100644
index 00000000..42e0e191
--- /dev/null
+++ b/src/composables/useDashboardSuggestions.ts
@@ -0,0 +1,315 @@
+import {
+  computed,
+  onMounted,
+  onUnmounted,
+  ref,
+  shallowRef,
+  toValue,
+  watch,
+  type MaybeRef,
+  type Ref,
+} from 'vue';
+import { useToast } from 'primevue/usetoast';
+import { decamelizeKeys, useDataApi } from '@/composables/axios';
+import {
+  buildAcceptDashboardSuggestionsEndpoint,
+  buildDashboardSuggestionEventsEndpoint,
+  buildDashboardSuggestionLabelSetsEndpoint,
+  buildDashboardSuggestionsEndpoint,
+  buildGenerateDashboardSuggestionsEndpoint,
+  buildLatestDashboardSuggestionRunEndpoint,
+  buildRejectDashboardSuggestionsEndpoint,
+  type DashboardSuggestion,
+  type DashboardSuggestionEvent,
+  type DashboardSuggestionLabelSet,
+  type GenerateDashboardSuggestionsPayload,
+  type SuggestionRun,
+  isRunActive,
+} from '@/views/dashboard/partials/dashboard-suggestions';
+
+export function useDashboardSuggestions(
+  sspId: Ref<string>,
+  enabled: MaybeRef<boolean> = true,
+) {
+  const {
+    data: pendingSuggestions,
+    execute: fetchPendingSuggestions,
+    isLoading: pendingSuggestionsLoading,
+  } = useDataApi<DashboardSuggestion[]>(null, {}, { immediate: false });
+  const historySuggestions = shallowRef<DashboardSuggestion[]>([]);
+  const { execute: fetchHistoryRequest, isLoading: historySuggestionsLoading } =
+    useDataApi<DashboardSuggestion[]>(null, {}, { immediate: false });
+  const {
+    data: labelSets,
+    execute: fetchLabelSets,
+    isLoading: labelSetsLoading,
+  } = useDataApi<DashboardSuggestionLabelSet[]>(null, {}, { immediate: false });
+
+  const { execute: generateRequest, isLoading: generating } =
+    useDataApi<SuggestionRun>(null, {}, { immediate: false });
+  const { execute: acceptRequest, isLoading: accepting } = useDataApi<void>(
+    null,
+    {},
+    { immediate: false },
+  );
+  const { execute: rejectRequest, isLoading: rejecting } = useDataApi<void>(
+    null,
+    {},
+    { immediate: false },
+  );
+  const { execute: eventsRequest, isLoading: loadingEvents } = useDataApi<
+    DashboardSuggestionEvent[]
+  >(null, {}, { immediate: false });
+
+  function canFetchSuggestions() {
+    return Boolean(toValue(enabled) && sspId.value);
+  }
+
+  async function refreshPendingSuggestions() {
+    if (!canFetchSuggestions()) {
+      return;
+    }
+
+    return fetchPendingSuggestions(
+      buildDashboardSuggestionsEndpoint(sspId.value, 'pending'),
+      { camelcaseStopPaths: ['data.labelSet'] },
+    );
+  }
+
+  async function refreshLabelSets() {
+    if (!canFetchSuggestions()) {
+      return;
+    }
+
+    return fetchLabelSets(
+      buildDashboardSuggestionLabelSetsEndpoint(sspId.value),
+      // Preserve raw label keys (e.g. `_agent`, `_plugin`) so the UI can filter
+      // out internal labels; otherwise camelcase conversion strips the `_`.
+      { camelcaseStopPaths: ['data.labels'] },
+    );
+  }
+
+  async function generateSuggestions(
+    payload: GenerateDashboardSuggestionsPayload,
+  ) {
+    if (!canFetchSuggestions()) {
+      return;
+    }
+
+    return generateRequest(
+      buildGenerateDashboardSuggestionsEndpoint(sspId.value),
+      {
+        method: 'POST',
+        data: payload,
+        transformRequest: [decamelizeKeys],
+      },
+    );
+  }
+
+  async function acceptSuggestions(ids: string[]) {
+    if (!canFetchSuggestions()) {
+      return;
+    }
+
+    await acceptRequest(buildAcceptDashboardSuggestionsEndpoint(sspId.value), {
+      method: 'POST',
+      data: { ids },
+      transformRequest: [decamelizeKeys],
+    });
+    await refreshPendingSuggestions();
+    await refreshHistorySuggestions();
+  }
+
+  async function refreshHistorySuggestions() {
+    if (!canFetchSuggestions()) {
+      historySuggestions.value = [];
+      return;
+    }
+
+    const statuses = ['accepted', 'rejected', 'superseded'];
+    const collected: DashboardSuggestion[] = [];
+
+    for (const status of statuses) {
+      const response = await fetchHistoryRequest(
+        buildDashboardSuggestionsEndpoint(sspId.value, status),
+        { camelcaseStopPaths: ['data.labelSet'] },
+      );
+      collected.push(...(response?.data.value?.data ?? []));
+    }
+
+    historySuggestions.value = collected;
+  }
+
+  async function rejectSuggestions(ids: string[], reason?: string) {
+    if (!canFetchSuggestions()) {
+      return;
+    }
+
+    await rejectRequest(buildRejectDashboardSuggestionsEndpoint(sspId.value), {
+      method: 'POST',
+      data: { ids, reason },
+      transformRequest: [decamelizeKeys],
+    });
+    await refreshPendingSuggestions();
+    await refreshHistorySuggestions();
+  }
+
+  async function fetchSuggestionEvents(suggestionId: string) {
+    if (!canFetchSuggestions()) {
+      return [];
+    }
+
+    const response = await eventsRequest(
+      buildDashboardSuggestionEventsEndpoint(sspId.value, suggestionId),
+    );
+    return response?.data.value?.data ?? [];
+  }
+
+  onMounted(() => {
+    if (canFetchSuggestions()) {
+      void refreshHistorySuggestions();
+    }
+  });
+
+  return {
+    pendingSuggestions,
+    historySuggestions,
+    labelSets,
+    pendingSuggestionsLoading,
+    historySuggestionsLoading,
+    labelSetsLoading,
+    generating,
+    accepting,
+    rejecting,
+    loadingEvents,
+    refreshPendingSuggestions,
+    refreshHistorySuggestions,
+    refreshLabelSets,
+    generateSuggestions,
+    acceptSuggestions,
+    rejectSuggestions,
+    fetchSuggestionEvents,
+  };
+}
+
+interface SuggestionRunPollerOptions {
+  stopOnPollError?: boolean;
+}
+
+export function useSuggestionRunPoller(
+  sspId: Ref<string>,
+  onPoll?: () => Promise<void> | void,
+  options: SuggestionRunPollerOptions = {},
+) {
+  const toast = useToast();
+  const run = ref<SuggestionRun>();
+  const timer = ref<number>();
+  const terminalToastShownFor = ref<string>();
+
+  const { execute, isLoading, error } = useDataApi<SuggestionRun>(
+    null,
+    {},
+    { immediate: false },
+  );
+
+  const progressPercent = computed(() => {
+    if (!run.value?.plannedCalls) {
+      return 0;
+    }
+    return Math.min(
+      100,
+      Math.round((run.value.completedCells / run.value.plannedCalls) * 100),
+    );
+  });
+
+  function stop() {
+    if (timer.value) {
+      window.clearInterval(timer.value);
+      timer.value = undefined;
+    }
+  }
+
+  async function pollLatest() {
+    if (!sspId.value) {
+      return;
+    }
+
+    try {
+      const response = await execute(
+        buildLatestDashboardSuggestionRunEndpoint(sspId.value),
+      );
+      const latestRun = response?.data.value?.data;
+      if (!latestRun) {
+        return;
+      }
+      run.value = latestRun;
+      await onPoll?.();
+
+      if (isRunActive(latestRun)) {
+        start();
+        return;
+      }
+
+      stop();
+      const runKey = latestRun.uuid ?? latestRun.id ?? latestRun.updatedAt;
+      if (runKey && terminalToastShownFor.value === runKey) {
+        return;
+      }
+      terminalToastShownFor.value = runKey;
+
+      if (latestRun.status === 'completed') {
+        toast.add({
+          severity: 'success',
+          summary: 'Suggestions ready',
+          detail: `${latestRun.completedCells} cells completed`,
+          life: 3000,
+        });
+      } else if (latestRun.status === 'failed') {
+        toast.add({
+          severity: 'error',
+          summary: 'Generation failed',
+          detail: latestRun.error ?? 'Dashboard suggestion generation failed.',
+          life: 5000,
+        });
+      }
+    } catch {
+      if (options.stopOnPollError) {
+        stop();
+      }
+    }
+  }
+
+  function start() {
+    if (timer.value) {
+      return;
+    }
+    timer.value = window.setInterval(() => {
+      void pollLatest();
+    }, 3000);
+  }
+
+  watch(
+    run,
+    (nextRun) => {
+      if (isRunActive(nextRun)) {
+        start();
+      } else {
+        stop();
+      }
+    },
+    { immediate: true },
+  );
+
+  onUnmounted(stop);
+
+  return {
+    run,
+    isPolling: computed(() => Boolean(timer.value)),
+    isLoading,
+    error,
+    progressPercent,
+    pollLatest,
+    start,
+    stop,
+  };
+}
diff --git a/src/router/__tests__/index.spec.ts b/src/router/__tests__/index.spec.ts
index 33cbe07f..1bf28353 100644
--- a/src/router/__tests__/index.spec.ts
+++ b/src/router/__tests__/index.spec.ts
@@ -36,4 +36,19 @@ describe('router', () => {
       }).path,
     ).toBe('/system/components/dashboards/component-1');
   });
+
+  it('registers the dashboard suggestions review route behind auth meta', () => {
+    const route = router
+      .getRoutes()
+      .find((route) => route.name === 'dashboards.suggestions');
+
+    expect(route?.path).toBe('/dashboards/suggestions/:sspId');
+    expect(route?.meta.requiresAuth).toBe(true);
+    expect(
+      router.resolve({
+        name: 'dashboards.suggestions',
+        params: { sspId: 'ssp-1' },
+      }).path,
+    ).toBe('/dashboards/suggestions/ssp-1');
+  });
 });
diff --git a/src/router/index.ts b/src/router/index.ts
index 01b6cbb3..5c02a8e8 100644
--- a/src/router/index.ts
+++ b/src/router/index.ts
@@ -37,6 +37,14 @@ const authenticatedRoutes = [
       requiresAuth: true,
     },
   },
+  {
+    path: '/dashboards/suggestions/:sspId',
+    name: 'dashboards.suggestions',
+    component: () => import('../views/dashboard/SuggestionsView.vue'),
+    meta: {
+      requiresAuth: true,
+    },
+  },
   {
     path: '/dashboards/:id',
     name: 'dashboards.view',
diff --git a/src/stores/ai-config.ts b/src/stores/ai-config.ts
new file mode 100644
index 00000000..c7382e62
--- /dev/null
+++ b/src/stores/ai-config.ts
@@ -0,0 +1,45 @@
+import { defineStore } from 'pinia';
+import { computed, ref } from 'vue';
+import { useDataApi } from '@/composables/axios';
+import { buildDashboardSuggestionsConfigEndpoint } from '@/views/dashboard/partials/dashboard-suggestions';
+
+interface DashboardSuggestionsConfig {
+  enabled: boolean;
+}
+
+export const useAiConfigStore = defineStore('ai-config', () => {
+  const fetched = ref(false);
+  const enabled = ref(false);
+
+  const { execute, isLoading, error } = useDataApi<DashboardSuggestionsConfig>(
+    null,
+    null,
+    { immediate: false },
+  );
+
+  async function fetchDashboardSuggestionsConfig() {
+    if (fetched.value) {
+      return enabled.value;
+    }
+
+    try {
+      const response = await execute(buildDashboardSuggestionsConfigEndpoint());
+      const config = response?.data.value?.data;
+      enabled.value = Boolean(config?.enabled);
+    } catch {
+      enabled.value = false;
+    } finally {
+      fetched.value = true;
+    }
+
+    return enabled.value;
+  }
+
+  return {
+    dashboardSuggestionsEnabled: computed(() => enabled.value),
+    dashboardSuggestionsConfigFetched: computed(() => fetched.value),
+    dashboardSuggestionsConfigLoading: isLoading,
+    dashboardSuggestionsConfigError: error,
+    fetchDashboardSuggestionsConfig,
+  };
+});
diff --git a/src/stores/filters.ts b/src/stores/filters.ts
index 18512962..c6ce6d1f 100644
--- a/src/stores/filters.ts
+++ b/src/stores/filters.ts
@@ -5,6 +5,7 @@ export interface Dashboard {
   id?: string;
   uuid?: string;
   name: string;
+  sspId?: string | null;
   filter: Filter;
   controls: Control[];
   components: SystemComponent[];
diff --git a/src/views/control-implementations/partials/ControlStatementImplementation.vue b/src/views/control-implementations/partials/ControlStatementImplementation.vue
index c738f144..ed15a7d9 100644
--- a/src/views/control-implementations/partials/ControlStatementImplementation.vue
+++ b/src/views/control-implementations/partials/ControlStatementImplementation.vue
@@ -30,6 +30,7 @@ import SystemImplementationComponentCreateForm from '@/components/system-securit
 import DashboardEvidenceCounter from '@/views/control-implementations/partials/DashboardEvidenceCounter.vue';
 import TooltipTitle from '@/components/TooltipTitle.vue';
 import Message from '@/volt/Message.vue';
+import { useAiConfigStore } from '@/stores/ai-config';
 import ControlStatementMetadata from './ControlStatementMetadata.vue';
 import ControlStatementSuggestions from './ControlStatementSuggestions.vue';
 import ControlStatementByComponents from './ControlStatementByComponents.vue';
@@ -57,6 +58,7 @@ const { system } = useSystemStore();
 const toast = useToast();
 const router = useRouter();
 const axios = useAuthenticatedInstance();
+const aiConfig = useAiConfigStore();
 
 const showCreateStatementModal = ref(false);
 const showEditStatementModal = ref(false);
@@ -393,6 +395,8 @@ watch(selectedComponent, () => {
 });
 
 onMounted(() => {
+  void aiConfig.fetchDashboardSuggestionsConfig();
+
   if (!system.securityPlan?.uuid) {
     return;
   }
@@ -1199,6 +1203,17 @@ function viewDashboardEvidence(dashboard: DashboardWithControls) {
   }
 }
 
+function openDashboardSuggestions() {
+  if (!resolvedSspId.value || !aiConfig.dashboardSuggestionsEnabled) {
+    return;
+  }
+
+  router.push({
+    name: 'dashboards.suggestions',
+    params: { sspId: resolvedSspId.value },
+  });
+}
+
 // Get unique titles for the dropdown (only show each title once)
 const uniqueEvidenceTitles = computed(() => {
   const titleMap = new Map<string, SearchableEvidence>();
@@ -1420,6 +1435,31 @@ async function submitEvidenceLinking() {
         @apply-suggestion="applySuggestedComponent"
       />
 
+      <div
+        v-if="showComponentsSection && aiConfig.dashboardSuggestionsEnabled"
+        class="mt-6"
+      >
+        <PrimaryButton
+          :disabled="!resolvedSspId"
+          @click="openDashboardSuggestions"
+        >
+          AI dashboard suggestions
+        </PrimaryButton>
+      </div>
+
+      <Message
+        v-if="
+          showComponentsSection &&
+          aiConfig.dashboardSuggestionsConfigFetched &&
+          !aiConfig.dashboardSuggestionsEnabled
+        "
+        severity="warn"
+        variant="outlined"
+        class="mt-6"
+      >
+        AI is not configured, so dashboard suggestions cannot be generated.
+      </Message>
+
       <ControlStatementByComponents
         v-if="showComponentsSection && localStatement"
         :by-components="localStatement.byComponents || []"
diff --git a/src/views/dashboard/CreateFormView.vue b/src/views/dashboard/CreateFormView.vue
index f6eb1f89..4950f887 100644
--- a/src/views/dashboard/CreateFormView.vue
+++ b/src/views/dashboard/CreateFormView.vue
@@ -10,6 +10,16 @@
         <label class="inline-block pb-2">Result Filter</label>
         <FormInput v-model="filter" />
       </div>
+      <div class="mb-4">
+        <label class="inline-block pb-2">Scope</label>
+        <Select
+          v-model="selectedSspId"
+          :options="sspScopeOptions"
+          optionLabel="label"
+          optionValue="value"
+          class="w-full"
+        />
+      </div>
       <div class="mb-4">
         <label class="inline-block pb-2">Controls</label>
         <MultiSelect
@@ -94,6 +104,7 @@ import type { Dashboard } from '@/stores/filters.ts';
 import FormInput from '@/components/forms/FormInput.vue';
 import PrimaryButton from '@/volt/PrimaryButton.vue';
 import MultiSelect from '@/volt/MultiSelect.vue';
+import Select from '@/volt/Select.vue';
 import type {
   Catalog,
   SystemSecurityPlan,
@@ -137,6 +148,7 @@ interface SelectComponent {
 
 const selectedControls = ref<ControlOption[]>([]);
 const selectedComponents = ref<ComponentOption[]>([]);
+const selectedSspId = ref<string | null>(null);
 const controls = ref<SelectControl[]>([]);
 const components = ref<SelectComponent[]>([]);
 const loadingControls = ref<boolean>(true);
@@ -152,6 +164,13 @@ const { data: catalogs } = useDataApi<Catalog[]>('/api/oscal/catalogs');
 const { data: systemSecurityPlans } = useDataApi<SystemSecurityPlan[]>(
   '/api/oscal/system-security-plans',
 );
+const sspScopeOptions = computed(() => [
+  { label: 'Global', value: null },
+  ...(systemSecurityPlans.value ?? []).map((ssp) => ({
+    label: ssp.metadata.title,
+    value: ssp.uuid,
+  })),
+]);
 const { execute: fetchFullCatalog } = useDataApi<Catalog>(null, null, {
   abortPrevious: false,
 });
@@ -339,6 +358,7 @@ async function submit() {
     await createDashboard({
       data: {
         ...dashboard.value,
+        sspId: selectedSspId.value,
         filter: parsedFilter,
         controls: controlIds,
         components: componentIds,
diff --git a/src/views/dashboard/IndexView.vue b/src/views/dashboard/IndexView.vue
index 6419ca10..4a37cb94 100644
--- a/src/views/dashboard/IndexView.vue
+++ b/src/views/dashboard/IndexView.vue
@@ -1,63 +1,85 @@
 <template>
   <CompliancePostureWidget />
 
-  <div v-if="dashboards && dashboards.length > 0">
-    <PageHeader>Dashboards</PageHeader>
-    <PageSubHeader>Findings grouped by query</PageSubHeader>
+  <div class="flex items-start justify-between gap-4">
+    <div>
+      <PageHeader>Dashboards</PageHeader>
+      <PageSubHeader>Findings grouped by query</PageSubHeader>
+    </div>
+    <div>
+      <RouterLink :to="{ name: 'dashboards.create' }">
+        <PrimaryButton>Create</PrimaryButton>
+      </RouterLink>
+    </div>
+  </div>
 
-    <div class="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-2 gap-4 mt-4">
-      <PageCard v-for="dashboard in dashboards" :key="dashboard.uuid">
-        <div class="flex justify-between items-center mb-2">
-          <h3 class="text-lg font-semibold text-zinc-600 dark:text-slate-300">
-            {{ dashboard.name }}
-          </h3>
-          <div>
-            <Chip
-              v-for="control in dashboard.controls"
-              :key="control.id"
-              :label="control.id"
-              class="mx-1"
-              v-tooltip.top="control.title"
-            />
-            <Chip
-              v-for="component in dashboard.components"
-              :key="component.uuid"
-              :label="component.title"
-              class="mx-1"
-              v-tooltip.top="component.title"
-            />
+  <div v-if="dashboards && dashboards.length > 0">
+    <section
+      v-for="group in dashboardGroups"
+      :key="group.key"
+      class="mt-6"
+      :data-testid="`dashboard-group-${group.key}`"
+    >
+      <h2 class="text-base font-semibold text-zinc-700 dark:text-slate-200">
+        {{ group.title }}
+      </h2>
+      <div class="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-2 gap-4 mt-3">
+        <PageCard v-for="dashboard in group.dashboards" :key="dashboard.uuid">
+          <div class="flex justify-between items-center mb-2">
+            <h3 class="text-lg font-semibold text-zinc-600 dark:text-slate-300">
+              {{ dashboard.name }}
+            </h3>
+            <div>
+              <Chip
+                v-for="control in dashboard.controls"
+                :key="control.id"
+                :label="control.id"
+                class="mx-1"
+                v-tooltip.top="control.title"
+              />
+              <Chip
+                v-for="component in dashboard.components"
+                :key="component.uuid"
+                :label="component.title"
+                class="mx-1"
+                v-tooltip.top="component.title"
+              />
+            </div>
           </div>
-        </div>
-        <div class="h-32">
-          <DashboardChart :filter="dashboard.filter" :dashboard="dashboard" />
-        </div>
-        <Button
-          label="Delete Dashboard"
-          @click.prevent="deleteDashboard(dashboard)"
-          class="bg-red-500 border-red-600 hover:bg-red-600 text-white dark:bg-red-700 dark:hover:bg-red-600 dark:border-red-700 mr-4"
-        >
-          Delete
-        </Button>
-      </PageCard>
-    </div>
+          <div class="h-32">
+            <DashboardChart :filter="dashboard.filter" :dashboard="dashboard" />
+          </div>
+          <Button
+            label="Delete Dashboard"
+            @click.prevent="deleteDashboard(dashboard)"
+            class="bg-red-500 border-red-600 hover:bg-red-600 text-white dark:bg-red-700 dark:hover:bg-red-600 dark:border-red-700 mr-4"
+          >
+            Delete
+          </Button>
+        </PageCard>
+      </div>
+    </section>
   </div>
 
-  <Message v-else severity="warn" variant="outlined">
+  <Message v-else severity="warn" variant="outlined" class="mt-6">
     <h4 class="font-bold">No Dashboards Found</h4>
     <p>
       Dashboards can be created on the
-      <RouterLink :to="{ name: 'evidence:index' }" class="underline"
-        >evidence
+      <RouterLink :to="{ name: 'evidence:index' }" class="underline">
+        evidence
       </RouterLink>
       page
     </p>
   </Message>
 </template>
+
 <script setup lang="ts">
+import { computed } from 'vue';
 import PageHeader from '@/components/PageHeader.vue';
 import PageCard from '@/components/PageCard.vue';
 import PageSubHeader from '@/components/PageSubHeader.vue';
 import type { Dashboard } from '@/stores/filters.ts';
+import type { SystemSecurityPlan } from '@/oscal';
 import DashboardChart from '@/views/dashboard/DashboardChart.vue';
 import CompliancePostureWidget from '@/views/dashboard/CompliancePostureWidget.vue';
 import { useConfirm } from 'primevue/useconfirm';
@@ -72,6 +94,9 @@ const toast = useToast();
 
 const { data: dashboards, execute: refreshDashboards } =
   useDataApi<Dashboard[]>('/api/filters');
+const { data: systemSecurityPlans } = useDataApi<SystemSecurityPlan[]>(
+  '/api/oscal/system-security-plans',
+);
 
 const { execute: executeDelete } = useDataApi<void>(
   null,
@@ -81,6 +106,49 @@ const { execute: executeDelete } = useDataApi<void>(
   { immediate: false },
 );
 
+const sspTitleById = computed(
+  () =>
+    new Map(
+      (systemSecurityPlans.value ?? []).map((ssp) => [
+        ssp.uuid,
+        ssp.metadata.title,
+      ]),
+    ),
+);
+
+const dashboardGroups = computed(() => {
+  const sections = [
+    {
+      key: 'global',
+      title: 'Global',
+      dashboards: (dashboards.value ?? []).filter(
+        (dashboard) => !dashboard.sspId,
+      ),
+    },
+  ];
+
+  const bySsp = new Map<string, Dashboard[]>();
+  for (const dashboard of dashboards.value ?? []) {
+    if (!dashboard.sspId) {
+      continue;
+    }
+    bySsp.set(dashboard.sspId, [
+      ...(bySsp.get(dashboard.sspId) ?? []),
+      dashboard,
+    ]);
+  }
+
+  for (const [sspId, scopedDashboards] of bySsp) {
+    sections.push({
+      key: sspId,
+      title: sspTitleById.value.get(sspId) ?? `SSP ${sspId}`,
+      dashboards: scopedDashboards,
+    });
+  }
+
+  return sections.filter((section) => section.dashboards.length > 0);
+});
+
 function deleteDashboard(dashboard: Dashboard) {
   confirm.require({
     message: `Are you sure you want to delete the ${dashboard.name} dashboard ?`,
diff --git a/src/views/dashboard/SuggestionsView.vue b/src/views/dashboard/SuggestionsView.vue
new file mode 100644
index 00000000..ae64b035
--- /dev/null
+++ b/src/views/dashboard/SuggestionsView.vue
@@ -0,0 +1,854 @@
+<template>
+  <div class="flex items-start justify-between gap-4">
+    <div>
+      <PageHeader>Dashboard suggestions</PageHeader>
+      <PageSubHeader>{{ sspTitle }}</PageSubHeader>
+    </div>
+    <PrimaryButton
+      v-if="
+        aiConfig.dashboardSuggestionsConfigFetched &&
+        aiConfig.dashboardSuggestionsEnabled
+      "
+      @click="showScopeDialog = true"
+    >
+      Generate suggestions
+    </PrimaryButton>
+  </div>
+
+  <Message
+    v-if="
+      aiConfig.dashboardSuggestionsConfigFetched &&
+      !aiConfig.dashboardSuggestionsEnabled
+    "
+    severity="warn"
+    variant="outlined"
+    class="mt-4"
+  >
+    AI is not configured, so dashboard suggestions cannot be generated.
+  </Message>
+
+  <Message
+    v-else-if="!aiConfig.dashboardSuggestionsConfigFetched"
+    severity="info"
+    variant="outlined"
+    class="mt-4"
+  >
+    Loading dashboard suggestions configuration.
+  </Message>
+
+  <div v-else-if="aiConfig.dashboardSuggestionsEnabled" class="mt-4 space-y-4">
+    <div class="flex flex-wrap items-center gap-3">
+      <span
+        class="inline-flex items-center gap-2 rounded-md border px-3 py-1 text-sm"
+      >
+        <i
+          v-if="runStatus === 'running' || runStatus === 'pending'"
+          class="pi pi-spin pi-spinner"
+        />
+        {{ runStatusLabel }}
+      </span>
+      <div v-if="run?.plannedCalls" class="min-w-64">
+        <div class="h-2 overflow-hidden rounded bg-zinc-200 dark:bg-slate-700">
+          <div
+            class="h-full bg-emerald-600"
+            :style="{ width: `${progressPercent}%` }"
+          />
+        </div>
+        <p class="mt-1 text-xs text-zinc-500">
+          {{ run.completedCells }} / {{ run.plannedCalls }} cells complete
+        </p>
+      </div>
+    </div>
+
+    <Message
+      v-if="run?.status === 'failed'"
+      severity="error"
+      variant="outlined"
+    >
+      <p>{{ run.error ?? 'Suggestion generation failed.' }}</p>
+      <ul v-if="run.failures?.length" class="mt-2 list-disc pl-5">
+        <li v-for="failure in run.failures" :key="failureKey(failure)">
+          {{ failure.controlKey ?? 'Unknown control' }} /
+          {{ failure.labelSetHash ?? 'Unknown label set' }}:
+          {{ failure.message ?? 'Failed' }}
+        </li>
+      </ul>
+    </Message>
+
+    <div class="flex gap-2 border-b border-zinc-200 dark:border-slate-700">
+      <button
+        class="px-4 py-2 font-semibold"
+        :class="activeTab === 'pending' ? 'border-b-2 border-primary' : ''"
+        @click="activeTab = 'pending'"
+      >
+        Pending
+      </button>
+      <button
+        class="px-4 py-2 font-semibold"
+        :class="activeTab === 'history' ? 'border-b-2 border-primary' : ''"
+        @click="activeTab = 'history'"
+      >
+        History
+      </button>
+    </div>
+
+    <div v-if="activeTab === 'pending'" class="space-y-4">
+      <div
+        v-if="selectedSuggestionIds.length"
+        class="flex flex-wrap items-center gap-2 rounded-md border border-zinc-200 p-3 dark:border-slate-700"
+      >
+        <span class="text-sm text-zinc-600 dark:text-slate-300">
+          {{ selectedSuggestionIds.length }} selected
+        </span>
+        <SecondaryButton @click="acceptSelected"
+          >Accept selected</SecondaryButton
+        >
+        <SecondaryButton @click="openRejectDialog(selectedSuggestionIds)">
+          Reject selected
+        </SecondaryButton>
+      </div>
+
+      <Message
+        v-if="!pendingSuggestionsLoading && pendingGroups.length === 0"
+        severity="info"
+        variant="outlined"
+      >
+        No pending dashboard suggestions.
+      </Message>
+
+      <PageCard
+        v-for="group in pendingGroups"
+        :key="group.hash"
+        :data-testid="`suggestion-group-${group.hash}`"
+      >
+        <div class="flex flex-wrap items-start justify-between gap-3">
+          <div>
+            <div class="flex flex-wrap items-center gap-2">
+              <h2
+                class="text-lg font-semibold text-zinc-700 dark:text-slate-200"
+              >
+                {{ groupTitle(group.suggestions[0]) }}
+              </h2>
+              <Chip
+                v-if="group.suggestions[0]?.action === 'extend'"
+                :label="`Extends: ${group.suggestions[0].targetFilterName ?? 'dashboard'}`"
+              />
+              <RouterLink
+                :to="{
+                  name: 'evidence:index',
+                  query: { filter: group.labels.join(' and ') },
+                }"
+                class="text-sm text-zinc-500 hover:underline focus-visible:underline"
+                :title="group.sampleTitles.slice(0, 3).join('\n')"
+              >
+                {{ group.evidenceCount }} matched evidence
+              </RouterLink>
+            </div>
+            <div class="mt-2 flex flex-wrap gap-2">
+              <Chip v-for="label in group.labels" :key="label" :label="label" />
+            </div>
+          </div>
+          <div class="flex gap-2">
+            <SecondaryButton @click="acceptGroup(group)">
+              Accept group
+            </SecondaryButton>
+            <SecondaryButton @click="openRejectDialog(groupIds(group))">
+              Reject group
+            </SecondaryButton>
+          </div>
+        </div>
+
+        <div class="mt-4 divide-y divide-zinc-200 dark:divide-slate-700">
+          <div
+            v-for="suggestion in group.suggestions"
+            :key="suggestion.id"
+            class="py-3"
+          >
+            <div class="flex flex-wrap items-start justify-between gap-3">
+              <label class="flex min-w-0 items-start gap-3">
+                <input
+                  v-model="selectedSuggestionIds"
+                  type="checkbox"
+                  :value="suggestion.id"
+                  class="mt-1"
+                />
+                <span>
+                  <span class="font-semibold">
+                    {{ suggestion.controlId }}
+                  </span>
+                  <span>{{ suggestion.controlTitle }}</span>
+                  <span class="ml-2 text-sm text-zinc-500">
+                    {{ confidenceLabel(suggestion.confidence) }}
+                  </span>
+                </span>
+              </label>
+              <div class="flex gap-2">
+                <SecondaryButton @click="toggleReasoning(suggestion.id)">
+                  Reasoning
+                </SecondaryButton>
+                <SecondaryButton @click="acceptOne(suggestion.id)">
+                  Accept
+                </SecondaryButton>
+                <SecondaryButton @click="openRejectDialog([suggestion.id])">
+                  Reject
+                </SecondaryButton>
+              </div>
+            </div>
+            <div
+              v-if="expandedReasoning.has(suggestion.id)"
+              class="mt-3 rounded-md bg-zinc-50 p-3 text-sm dark:bg-slate-800"
+            >
+              <p>
+                <span class="font-semibold">Control fit:</span>
+                {{
+                  suggestion.controlFitReasoning ??
+                  suggestion.reasoning ??
+                  'No control-fit reasoning provided.'
+                }}
+              </p>
+              <p class="mt-2">
+                <span class="font-semibold">System relevance:</span>
+                {{
+                  suggestion.systemRelevanceReasoning ??
+                  suggestion.reasoning ??
+                  'No system-relevance reasoning provided.'
+                }}
+              </p>
+            </div>
+          </div>
+        </div>
+      </PageCard>
+    </div>
+
+    <div v-else class="space-y-3">
+      <Message
+        v-if="!historySuggestionsLoading && !historySuggestions?.length"
+        severity="info"
+        variant="outlined"
+      >
+        No suggestion history.
+      </Message>
+      <PageCard
+        v-for="suggestion in historySuggestions ?? []"
+        :key="suggestion.id"
+      >
+        <div class="flex flex-wrap items-center justify-between gap-3">
+          <div>
+            <p class="font-semibold">
+              {{ suggestion.controlId }} {{ suggestion.controlTitle }}
+            </p>
+            <p class="text-sm text-zinc-500">
+              {{ suggestion.status }} · {{ groupTitle(suggestion) }}
+            </p>
+          </div>
+          <SecondaryButton @click="openAuditDialog(suggestion.id)">
+            Audit events
+          </SecondaryButton>
+        </div>
+      </PageCard>
+
+      <PageCard v-if="run">
+        <h2 class="text-base font-semibold">Latest run</h2>
+        <p class="mt-1 text-sm text-zinc-600 dark:text-slate-300">
+          {{ run.status }} · {{ run.completedCells }}/{{
+            run.plannedCalls
+          }}
+          completed · {{ run.failedCells }} failed
+        </p>
+        <p class="mt-1 text-sm text-zinc-500">
+          Scope:
+          {{ run.scope?.controlKeys?.length ?? 'all' }} controls,
+          {{ run.scope?.labelSetHashes?.length ?? 'all' }} label-sets
+        </p>
+      </PageCard>
+    </div>
+  </div>
+
+  <SuggestionScopeDialog
+    v-if="aiConfig.dashboardSuggestionsEnabled"
+    v-model:visible="showScopeDialog"
+    :ssp-id="sspId"
+    :controls="controlOptions"
+    :labelSets="labelSets ?? []"
+    :generating="generating"
+    :ceilingError="scopeCeilingError"
+    @scope-change="scopeCeilingError = ''"
+    @generate="generate"
+  />
+
+  <Dialog
+    v-if="aiConfig.dashboardSuggestionsEnabled"
+    v-model:visible="showRejectDialog"
+    modal
+    header="Reject suggestions"
+    size="sm"
+  >
+    <label class="inline-block pb-2" for="reject-reason">Reason</label>
+    <Textarea
+      id="reject-reason"
+      v-model="rejectReason"
+      rows="4"
+      class="w-full"
+    />
+    <template #footer>
+      <SecondaryButton @click="showRejectDialog = false"
+        >Cancel</SecondaryButton
+      >
+      <PrimaryButton @click="rejectPending">Reject</PrimaryButton>
+    </template>
+  </Dialog>
+
+  <Dialog
+    v-if="aiConfig.dashboardSuggestionsEnabled"
+    v-model:visible="showAuditDialog"
+    modal
+    header="Audit events"
+    size="md"
+  >
+    <Message v-if="!auditEvents.length" severity="info" variant="outlined">
+      No audit events found.
+    </Message>
+    <ol v-else class="space-y-3">
+      <li
+        v-for="event in auditEvents"
+        :key="event.id ?? event.uuid ?? `${event.action}-${event.createdAt}`"
+        class="rounded-md border border-zinc-200 p-3 dark:border-slate-700"
+      >
+        <p class="font-semibold">{{ event.action ?? 'event' }}</p>
+        <p class="text-sm text-zinc-500">
+          {{ event.actor ?? 'Unknown actor' }} · {{ event.createdAt }}
+        </p>
+        <p v-if="event.reasoning" class="mt-2 text-sm">
+          {{ event.reasoning }}
+        </p>
+        <p v-if="event.resultingFilterName" class="mt-2 text-sm">
+          Resulting filter: {{ event.resultingFilterName }}
+        </p>
+      </li>
+    </ol>
+  </Dialog>
+</template>
+
+<script setup lang="ts">
+import { computed, onMounted, ref, watch } from 'vue';
+import { RouterLink, useRoute } from 'vue-router';
+import PageCard from '@/components/PageCard.vue';
+import PageHeader from '@/components/PageHeader.vue';
+import PageSubHeader from '@/components/PageSubHeader.vue';
+import type {
+  Catalog,
+  Control,
+  ImplementedRequirement,
+  SystemSecurityPlan,
+} from '@/oscal';
+import { useAuthenticatedInstance, useDataApi } from '@/composables/axios';
+import {
+  useDashboardSuggestions,
+  useSuggestionRunPoller,
+} from '@/composables/useDashboardSuggestions';
+import { useAiConfigStore } from '@/stores/ai-config';
+import type { DataResponse } from '@/stores/types';
+import Chip from '@/volt/Chip.vue';
+import Dialog from '@/volt/Dialog.vue';
+import Message from '@/volt/Message.vue';
+import PrimaryButton from '@/volt/PrimaryButton.vue';
+import SecondaryButton from '@/volt/SecondaryButton.vue';
+import Textarea from '@/volt/Textarea.vue';
+import SuggestionScopeDialog from './partials/SuggestionScopeDialog.vue';
+import {
+  formatLabelSet,
+  type DashboardSuggestion,
+  type DashboardSuggestionEvent,
+  type GenerateDashboardSuggestionsPayload,
+  type SuggestionRunFailure,
+} from './partials/dashboard-suggestions';
+
+const route = useRoute();
+const sspId = computed(() => String(route.params.sspId));
+const aiConfig = useAiConfigStore();
+const axios = useAuthenticatedInstance();
+const activeTab = ref<'pending' | 'history'>('pending');
+const showScopeDialog = ref(false);
+const showRejectDialog = ref(false);
+const showAuditDialog = ref(false);
+const rejectReason = ref('');
+const rejectIds = ref<string[]>([]);
+const selectedSuggestionIds = ref<string[]>([]);
+const expandedReasoning = ref(new Set<string>());
+const auditEvents = ref<DashboardSuggestionEvent[]>([]);
+const scopeCeilingError = ref('');
+const controlTitleById = ref(new Map<string, string>());
+const controlCatalogById = ref(new Map<string, string>());
+const controlProfileTitlesById = ref(new Map<string, string[]>());
+
+interface SspProfileBinding {
+  id?: string;
+  uuid?: string;
+  title: string;
+}
+
+interface ResolvedControlWithCatalog {
+  controlId: string;
+  title?: string;
+  catalogId?: string;
+}
+
+const { data: systemSecurityPlan } = useDataApi<SystemSecurityPlan>(
+  computed(() => `/api/oscal/system-security-plans/${sspId.value}/full`),
+);
+
+const {
+  pendingSuggestions,
+  historySuggestions,
+  labelSets,
+  pendingSuggestionsLoading,
+  historySuggestionsLoading,
+  generating,
+  refreshPendingSuggestions,
+  refreshHistorySuggestions,
+  refreshLabelSets,
+  generateSuggestions,
+  acceptSuggestions,
+  rejectSuggestions,
+  fetchSuggestionEvents,
+} = useDashboardSuggestions(
+  sspId,
+  computed(
+    () =>
+      aiConfig.dashboardSuggestionsConfigFetched &&
+      aiConfig.dashboardSuggestionsEnabled,
+  ),
+);
+
+const { run, progressPercent, pollLatest, start } = useSuggestionRunPoller(
+  sspId,
+  async () => {
+    await refreshPendingSuggestions();
+  },
+);
+
+const sspTitle = computed(
+  () => systemSecurityPlan.value?.metadata?.title ?? 'Selected SSP',
+);
+const runStatus = computed(() => run.value?.status ?? 'idle');
+const runStatusLabel = computed(() => {
+  if (!run.value) {
+    return 'Idle';
+  }
+  if (run.value.status === 'pending' || run.value.status === 'running') {
+    return `${run.value.status} (${run.value.completedCells}/${run.value.plannedCalls})`;
+  }
+  return run.value.status;
+});
+
+const controlOptions = computed(() =>
+  (
+    systemSecurityPlan.value?.controlImplementation?.implementedRequirements ??
+    []
+  )
+    .map((requirement: ImplementedRequirement) => {
+      const controlKey = normalizeControlId(requirement.controlId);
+      const title = controlTitleById.value.get(controlKey);
+      const catalogTitle = controlCatalogById.value.get(controlKey);
+      const profileTitles =
+        controlProfileTitlesById.value.get(controlKey) ?? [];
+      const titleLabel = title
+        ? `${requirement.controlId} - ${title}`
+        : requirement.controlId;
+      return {
+        label: titleLabel,
+        value: requirement.controlId,
+        controlId: requirement.controlId,
+        title,
+        catalogTitle,
+        profileTitles,
+      };
+    })
+    .sort((left, right) => left.label.localeCompare(right.label)),
+);
+
+const labelSetByHash = computed(
+  () =>
+    new Map(
+      (labelSets.value ?? []).map((labelSet) => [labelSet.hash, labelSet]),
+    ),
+);
+
+const pendingGroups = computed(() => {
+  const groups = new Map<
+    string,
+    {
+      hash: string;
+      labels: string[];
+      evidenceCount: number;
+      sampleTitles: string[];
+      suggestions: DashboardSuggestion[];
+    }
+  >();
+
+  for (const suggestion of pendingSuggestions.value ?? []) {
+    const matched = labelSetByHash.value.get(suggestion.labelSetHash);
+    const group = groups.get(suggestion.labelSetHash) ?? {
+      hash: suggestion.labelSetHash,
+      labels: formatLabelSet(
+        matched?.labels ?? suggestion.labelSet ?? suggestion.labels ?? {},
+      ),
+      evidenceCount: matched?.evidenceCount ?? 0,
+      sampleTitles: matched?.sampleTitles ?? [],
+      suggestions: [],
+    };
+    group.suggestions.push(suggestion);
+    groups.set(suggestion.labelSetHash, group);
+  }
+
+  return Array.from(groups.values());
+});
+
+onMounted(async () => {
+  await aiConfig.fetchDashboardSuggestionsConfig();
+  if (!aiConfig.dashboardSuggestionsEnabled) {
+    return;
+  }
+  await refreshLabelSets();
+  await refreshHistorySuggestions();
+  await pollLatest();
+  if (run.value?.status === 'pending' || run.value?.status === 'running') {
+    start();
+  }
+});
+
+watch(
+  () => [
+    sspId.value,
+    aiConfig.dashboardSuggestionsConfigFetched,
+    aiConfig.dashboardSuggestionsEnabled,
+  ],
+  ([, configFetched, enabled]) => {
+    if (!configFetched || !enabled) {
+      controlTitleById.value = new Map();
+      controlCatalogById.value = new Map();
+      controlProfileTitlesById.value = new Map();
+      return;
+    }
+    void loadControlMetadata();
+  },
+  { immediate: true },
+);
+
+function groupTitle(suggestion: DashboardSuggestion | undefined) {
+  if (!suggestion) {
+    return 'Proposed dashboard';
+  }
+  return (
+    suggestion.proposedFilterName ??
+    suggestion.targetFilterName ??
+    'Proposed dashboard'
+  );
+}
+
+function normalizeControlId(controlId?: string) {
+  return (controlId ?? '').toLowerCase();
+}
+
+async function loadControlMetadata() {
+  controlTitleById.value = new Map();
+  controlCatalogById.value = new Map();
+  controlProfileTitlesById.value = new Map();
+
+  if (!sspId.value) {
+    return;
+  }
+
+  try {
+    const profilesResponse = await axios.get<DataResponse<SspProfileBinding[]>>(
+      `/api/oscal/system-security-plans/${encodeURIComponent(sspId.value)}/profiles`,
+    );
+    const profileBindings = profilesResponse.data?.data ?? [];
+    const resolvedProfileResults = await Promise.allSettled(
+      profileBindings
+        .map((profileBinding) => ({
+          uuid: profileBinding.uuid ?? profileBinding.id,
+          title: profileBinding.title,
+        }))
+        .filter(
+          (profileBinding): profileBinding is { uuid: string; title: string } =>
+            Boolean(profileBinding.uuid),
+        )
+        .map(async (profileBinding) => {
+          const response = await axios.get<
+            DataResponse<ResolvedControlWithCatalog[]>
+          >(
+            `/api/oscal/profiles/${encodeURIComponent(profileBinding.uuid)}/resolved-with-catalogs`,
+          );
+          return {
+            title: profileBinding.title,
+            controls: response.data?.data ?? [],
+          };
+        }),
+    );
+
+    const titles = new Map(controlTitleById.value);
+    const controlCatalogIds = new Map<string, string>();
+    const profileTitles = new Map<string, Set<string>>();
+
+    for (const result of resolvedProfileResults) {
+      if (result.status !== 'fulfilled') {
+        continue;
+      }
+
+      for (const control of result.value.controls) {
+        const controlKey = normalizeControlId(control.controlId);
+        if (!controlKey) {
+          continue;
+        }
+        if (control.title && !titles.has(controlKey)) {
+          titles.set(controlKey, control.title);
+        }
+        if (control.catalogId && !controlCatalogIds.has(controlKey)) {
+          controlCatalogIds.set(controlKey, control.catalogId);
+        }
+        const profiles = profileTitles.get(controlKey) ?? new Set();
+        profiles.add(result.value.title);
+        profileTitles.set(controlKey, profiles);
+      }
+    }
+
+    const catalogTitles = await loadCatalogControlTitles(
+      titles,
+      controlCatalogIds,
+    );
+    controlTitleById.value = titles;
+    controlCatalogById.value = catalogTitles;
+    controlProfileTitlesById.value = new Map(
+      Array.from(profileTitles.entries()).map(([controlId, profiles]) => [
+        controlId,
+        Array.from(profiles).sort((left, right) => left.localeCompare(right)),
+      ]),
+    );
+  } catch {
+    const titles = new Map<string, string>();
+    const catalogTitles = await loadCatalogControlTitles(titles, new Map());
+    controlTitleById.value = titles;
+    controlCatalogById.value = catalogTitles;
+    controlProfileTitlesById.value = new Map();
+  }
+}
+
+async function loadCatalogControlTitles(
+  titles: Map<string, string>,
+  controlCatalogIds: Map<string, string>,
+) {
+  const catalogTitles = new Map<string, string>();
+  const implementedControlIds = new Set(
+    systemSecurityPlan.value?.controlImplementation?.implementedRequirements
+      ?.map((requirement) => normalizeControlId(requirement.controlId))
+      .filter(Boolean) ?? [],
+  );
+  const missingControlIds = new Set(
+    Array.from(implementedControlIds).filter(
+      (controlId) => !titles.has(controlId),
+    ),
+  );
+
+  try {
+    const catalogsResponse = await axios.get<DataResponse<Catalog[]>>(
+      '/api/oscal/catalogs',
+    );
+    const catalogs = catalogsResponse.data?.data ?? [];
+    const catalogTitleByUuid = new Map(
+      catalogs
+        .filter((catalog) => catalog.uuid)
+        .map((catalog) => [catalog.uuid, catalog.metadata?.title ?? '']),
+    );
+
+    for (const [controlId, catalogId] of controlCatalogIds) {
+      const catalogTitle = catalogTitleByUuid.get(catalogId);
+      if (catalogTitle) {
+        catalogTitles.set(controlId, catalogTitle);
+      }
+    }
+
+    const referencedCatalogIds = new Set(controlCatalogIds.values());
+    const catalogIds = catalogs
+      .map((catalog) => catalog.uuid)
+      .filter(
+        (catalogId) =>
+          catalogId &&
+          missingControlIds.size > 0 &&
+          (referencedCatalogIds.size === 0 ||
+            referencedCatalogIds.has(catalogId)),
+      );
+
+    for (const catalogId of catalogIds) {
+      const response = await axios.get<DataResponse<Catalog>>(
+        `/api/oscal/catalogs/${encodeURIComponent(catalogId)}/full`,
+      );
+      collectControlTitles(
+        response.data?.data,
+        titles,
+        catalogTitles,
+        missingControlIds,
+      );
+      if (missingControlIds.size === 0) {
+        break;
+      }
+    }
+  } catch {
+    return catalogTitles;
+  }
+
+  return catalogTitles;
+}
+
+function collectControlTitles(
+  catalog: Catalog | undefined,
+  titles: Map<string, string>,
+  catalogTitles: Map<string, string>,
+  missingControlIds: Set<string>,
+) {
+  for (const group of catalog?.groups ?? []) {
+    for (const control of group.controls ?? []) {
+      collectControlTitle(
+        control,
+        titles,
+        catalogTitles,
+        missingControlIds,
+        catalog,
+      );
+    }
+  }
+  for (const control of catalog?.controls ?? []) {
+    collectControlTitle(
+      control,
+      titles,
+      catalogTitles,
+      missingControlIds,
+      catalog,
+    );
+  }
+}
+
+function collectControlTitle(
+  control: Control,
+  titles: Map<string, string>,
+  catalogTitles: Map<string, string>,
+  missingControlIds: Set<string>,
+  catalog: Catalog | undefined,
+) {
+  const controlKey = normalizeControlId(control.id);
+  if (controlKey && control.title && !titles.has(controlKey)) {
+    titles.set(controlKey, control.title);
+    missingControlIds.delete(controlKey);
+  }
+  if (
+    controlKey &&
+    catalog?.metadata?.title &&
+    !catalogTitles.has(controlKey)
+  ) {
+    catalogTitles.set(controlKey, catalog.metadata.title);
+  }
+  for (const childControl of control.controls ?? []) {
+    collectControlTitle(
+      childControl,
+      titles,
+      catalogTitles,
+      missingControlIds,
+      catalog,
+    );
+  }
+}
+
+function groupIds(group: { suggestions: DashboardSuggestion[] }) {
+  return group.suggestions.map((suggestion) => suggestion.id);
+}
+
+function confidenceLabel(confidence: number | undefined) {
+  if (confidence === undefined || confidence === null) {
+    return 'Confidence unavailable';
+  }
+  return `${Math.round(confidence * 100)}% confidence`;
+}
+
+function failureKey(failure: SuggestionRunFailure) {
+  return `${failure.controlKey ?? 'control'}-${failure.labelSetHash ?? 'label'}-${failure.message ?? 'failed'}`;
+}
+
+function toggleReasoning(id: string) {
+  const next = new Set(expandedReasoning.value);
+  if (next.has(id)) {
+    next.delete(id);
+  } else {
+    next.add(id);
+  }
+  expandedReasoning.value = next;
+}
+
+async function generate(payload: GenerateDashboardSuggestionsPayload) {
+  scopeCeilingError.value = '';
+  try {
+    const response = await generateSuggestions(payload);
+    const generatedRun = response?.data.value?.data;
+    if (generatedRun) {
+      run.value = generatedRun;
+      start();
+    }
+    showScopeDialog.value = false;
+    await refreshPendingSuggestions();
+  } catch (error) {
+    scopeCeilingError.value = extractErrorMessage(error);
+  }
+}
+
+async function acceptOne(id: string) {
+  await acceptSuggestions([id]);
+  selectedSuggestionIds.value = selectedSuggestionIds.value.filter(
+    (selectedId) => selectedId !== id,
+  );
+}
+
+async function acceptGroup(group: { suggestions: DashboardSuggestion[] }) {
+  await acceptSuggestions(groupIds(group));
+  selectedSuggestionIds.value = selectedSuggestionIds.value.filter(
+    (id) => !groupIds(group).includes(id),
+  );
+}
+
+async function acceptSelected() {
+  const ids = [...selectedSuggestionIds.value];
+  await acceptSuggestions(ids);
+  selectedSuggestionIds.value = [];
+}
+
+function openRejectDialog(ids: string[]) {
+  rejectIds.value = [...ids];
+  rejectReason.value = '';
+  showRejectDialog.value = true;
+}
+
+async function rejectPending() {
+  const ids = [...rejectIds.value];
+  await rejectSuggestions(ids, rejectReason.value || undefined);
+  selectedSuggestionIds.value = selectedSuggestionIds.value.filter(
+    (id) => !ids.includes(id),
+  );
+  showRejectDialog.value = false;
+}
+
+async function openAuditDialog(id: string) {
+  auditEvents.value = await fetchSuggestionEvents(id);
+  showAuditDialog.value = true;
+}
+
+function extractErrorMessage(error: unknown) {
+  const maybeError = error as {
+    response?: { data?: { error?: string; message?: string; data?: unknown } };
+    message?: string;
+  };
+  return (
+    maybeError.response?.data?.error ??
+    maybeError.response?.data?.message ??
+    maybeError.message ??
+    'Generation request failed.'
+  );
+}
+</script>
diff --git a/src/views/dashboard/__tests__/IndexView.spec.ts b/src/views/dashboard/__tests__/IndexView.spec.ts
new file mode 100644
index 00000000..37362ea1
--- /dev/null
+++ b/src/views/dashboard/__tests__/IndexView.spec.ts
@@ -0,0 +1,118 @@
+import { mount } from '@vue/test-utils';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { shallowRef } from 'vue';
+import type { Dashboard } from '@/stores/filters';
+import type { SystemSecurityPlan } from '@/oscal';
+
+const dashboards = shallowRef<Dashboard[]>([]);
+const systemSecurityPlans = shallowRef<SystemSecurityPlan[]>([]);
+
+const mocks = vi.hoisted(() => ({
+  confirmRequire: vi.fn(),
+  toastAdd: vi.fn(),
+  refreshDashboards: vi.fn(),
+  deleteDashboard: vi.fn(),
+}));
+
+vi.mock('primevue/useconfirm', () => ({
+  useConfirm: () => ({ require: mocks.confirmRequire }),
+}));
+
+vi.mock('primevue/usetoast', () => ({
+  useToast: () => ({ add: mocks.toastAdd }),
+}));
+
+vi.mock('@/composables/axios', () => ({
+  useDataApi: (url?: string | null) => {
+    if (url === '/api/filters') {
+      return { data: dashboards, execute: mocks.refreshDashboards };
+    }
+    if (url === '/api/oscal/system-security-plans') {
+      return { data: systemSecurityPlans };
+    }
+    if (url === null) {
+      return { execute: mocks.deleteDashboard };
+    }
+    throw new Error(`Unexpected useDataApi call: ${url}`);
+  },
+}));
+
+vi.mock('@/views/dashboard/DashboardChart.vue', () => ({
+  default: { name: 'DashboardChart', template: '<div />' },
+}));
+
+vi.mock('@/views/dashboard/CompliancePostureWidget.vue', () => ({
+  default: { name: 'CompliancePostureWidget', template: '<div />' },
+}));
+
+import IndexView from '../IndexView.vue';
+
+function makeDashboard(name: string, sspId: string | null = null): Dashboard {
+  return {
+    id: name,
+    uuid: name,
+    name,
+    sspId,
+    filter: {} as Dashboard['filter'],
+    controls: [],
+    components: [],
+  };
+}
+
+function makeSsp(uuid: string, title: string): SystemSecurityPlan {
+  return {
+    uuid,
+    metadata: { title } as SystemSecurityPlan['metadata'],
+  } as SystemSecurityPlan;
+}
+
+function mountView() {
+  return mount(IndexView, {
+    global: {
+      stubs: {
+        PageHeader: { template: '<h1><slot /></h1>' },
+        PageSubHeader: { template: '<p><slot /></p>' },
+        PageCard: { template: '<section><slot /></section>' },
+        Chip: { props: ['label'], template: '<span>{{ label }}</span>' },
+        Message: { template: '<div><slot /></div>' },
+        PrimaryButton: {
+          template: '<button @click="$emit(\'click\')"><slot /></button>',
+        },
+        RouterLink: { props: ['to'], template: '<a><slot /></a>' },
+      },
+    },
+  });
+}
+
+describe('Dashboard IndexView', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    dashboards.value = [];
+    systemSecurityPlans.value = [];
+  });
+
+  it('does not render the AI suggestions launcher on the global dashboard index', () => {
+    dashboards.value = [makeDashboard('Global dashboard')];
+    const wrapper = mountView();
+
+    expect(wrapper.text()).not.toContain('AI suggestions');
+    expect(wrapper.text()).toContain('Global dashboard');
+  });
+
+  it('groups dashboards by global and owning SSP scopes', () => {
+    dashboards.value = [
+      makeDashboard('Global dashboard'),
+      makeDashboard('Scoped dashboard', 'ssp-1'),
+    ];
+    systemSecurityPlans.value = [makeSsp('ssp-1', 'Payments SSP')];
+
+    const wrapper = mountView();
+
+    expect(
+      wrapper.find('[data-testid="dashboard-group-global"]').text(),
+    ).toContain('Global');
+    expect(
+      wrapper.find('[data-testid="dashboard-group-ssp-1"]').text(),
+    ).toContain('Payments SSP');
+  });
+});
diff --git a/src/views/dashboard/__tests__/SuggestionsView.spec.ts b/src/views/dashboard/__tests__/SuggestionsView.spec.ts
new file mode 100644
index 00000000..8c4543b7
--- /dev/null
+++ b/src/views/dashboard/__tests__/SuggestionsView.spec.ts
@@ -0,0 +1,349 @@
+import { flushPromises, mount } from '@vue/test-utils';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { nextTick } from 'vue';
+import type { SystemSecurityPlan } from '@/oscal';
+import SuggestionScopeDialog from '../partials/SuggestionScopeDialog.vue';
+
+const state = vi.hoisted(() => ({
+  pendingSuggestions: { value: [] as unknown[] },
+  historySuggestions: { value: [] as unknown[] },
+  labelSets: { value: [] as unknown[] },
+  ssp: { value: undefined as unknown },
+  acceptSuggestions: vi.fn(),
+  rejectSuggestions: vi.fn(),
+  generateSuggestions: vi.fn(),
+  fetchSuggestionEvents: vi.fn(),
+  refreshPendingSuggestions: vi.fn(),
+  refreshHistorySuggestions: vi.fn(),
+  refreshLabelSets: vi.fn(),
+  pollLatest: vi.fn(),
+  start: vi.fn(),
+  axiosGet: vi.fn(),
+  fetchConfig: vi.fn(),
+  aiEnabled: true,
+  aiFetched: true,
+}));
+
+vi.mock('vue-router', () => ({
+  RouterLink: {
+    props: ['to'],
+    template: '<a :data-to="JSON.stringify(to)"><slot /></a>',
+  },
+  useRoute: () => ({ params: { sspId: 'ssp-1' } }),
+}));
+
+vi.mock('@/stores/ai-config', () => ({
+  useAiConfigStore: () => ({
+    get dashboardSuggestionsEnabled() {
+      return state.aiEnabled;
+    },
+    get dashboardSuggestionsConfigFetched() {
+      return state.aiFetched;
+    },
+    fetchDashboardSuggestionsConfig: state.fetchConfig,
+  }),
+}));
+
+vi.mock('@/composables/axios', () => ({
+  useAuthenticatedInstance: () => ({ get: state.axiosGet }),
+  useDataApi: () => ({ data: state.ssp }),
+}));
+
+vi.mock('@/composables/useDashboardSuggestions', () => ({
+  useDashboardSuggestions: () => ({
+    pendingSuggestions: state.pendingSuggestions,
+    historySuggestions: state.historySuggestions,
+    labelSets: state.labelSets,
+    pendingSuggestionsLoading: { value: false },
+    historySuggestionsLoading: { value: false },
+    generating: { value: false },
+    refreshPendingSuggestions: state.refreshPendingSuggestions,
+    refreshHistorySuggestions: state.refreshHistorySuggestions,
+    refreshLabelSets: state.refreshLabelSets,
+    generateSuggestions: state.generateSuggestions,
+    acceptSuggestions: state.acceptSuggestions,
+    rejectSuggestions: state.rejectSuggestions,
+    fetchSuggestionEvents: state.fetchSuggestionEvents,
+  }),
+  useSuggestionRunPoller: () => ({
+    run: { value: undefined },
+    progressPercent: { value: 0 },
+    pollLatest: state.pollLatest,
+    start: state.start,
+  }),
+}));
+
+import SuggestionsView from '../SuggestionsView.vue';
+
+function mountView() {
+  return mount(SuggestionsView, {
+    global: {
+      stubs: {
+        PageHeader: { template: '<h1><slot /></h1>' },
+        PageSubHeader: { template: '<p><slot /></p>' },
+        PageCard: { template: '<section><slot /></section>' },
+        Chip: { props: ['label'], template: '<span>{{ label }}</span>' },
+        Message: { template: '<div><slot /></div>' },
+        SuggestionScopeDialog: {
+          name: 'SuggestionScopeDialog',
+          props: ['controls'],
+          template:
+            '<div><span v-for="control in controls" :key="control.value">{{ control.label }}</span></div>',
+        },
+        Dialog: { template: '<div><slot /><slot name="footer" /></div>' },
+        Textarea: {
+          props: ['modelValue'],
+          emits: ['update:modelValue'],
+          template:
+            '<textarea :value="modelValue" @input="$emit(\'update:modelValue\', $event.target.value)" />',
+        },
+        PrimaryButton: {
+          emits: ['click'],
+          template: '<button @click="$emit(\'click\')"><slot /></button>',
+        },
+        SecondaryButton: {
+          emits: ['click'],
+          template: '<button @click="$emit(\'click\')"><slot /></button>',
+        },
+      },
+    },
+  });
+}
+
+describe('SuggestionsView', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    state.aiEnabled = true;
+    state.aiFetched = true;
+    state.fetchConfig.mockImplementation(async () => {
+      state.aiFetched = true;
+      return state.aiEnabled;
+    });
+    state.ssp.value = {
+      uuid: 'ssp-1',
+      metadata: { title: 'Payments SSP' },
+      controlImplementation: {
+        implementedRequirements: [{ controlId: 'ac-1' }, { controlId: 'AC-2' }],
+      },
+    } as unknown as SystemSecurityPlan;
+    state.pendingSuggestions.value = [
+      {
+        id: 'sug-1',
+        status: 'pending',
+        controlId: 'AC-1',
+        controlTitle: 'Access control policy',
+        labelSetHash: 'hash-1',
+        confidence: 0.91,
+        controlFitReasoning: 'Fits AC-1',
+        systemRelevanceReasoning: 'Relevant to payments',
+        action: 'create',
+        proposedFilterName: 'Production access',
+      },
+      {
+        id: 'sug-2',
+        status: 'pending',
+        controlId: 'AC-2',
+        controlTitle: 'Account management',
+        labelSetHash: 'hash-1',
+        confidence: 0.8,
+        controlFitReasoning: 'Fits AC-2',
+        systemRelevanceReasoning: 'Relevant to accounts',
+        action: 'create',
+        proposedFilterName: 'Production access',
+      },
+    ];
+    state.labelSets.value = [
+      {
+        hash: 'hash-1',
+        labels: { _agent: 'scanner', env: 'prod' },
+        evidenceCount: 7,
+        sampleTitles: ['Scanner evidence'],
+      },
+    ];
+    state.historySuggestions.value = [];
+    state.fetchSuggestionEvents.mockResolvedValue([]);
+    state.axiosGet.mockImplementation(async (url: string) => {
+      if (url === '/api/oscal/catalogs') {
+        return {
+          data: {
+            data: [{ uuid: 'catalog-1', metadata: { title: 'Catalog' } }],
+          },
+        };
+      }
+      if (url === '/api/oscal/catalogs/catalog-1/full') {
+        return {
+          data: {
+            data: {
+              uuid: 'catalog-1',
+              metadata: { title: 'Catalog' },
+              groups: [
+                {
+                  id: 'ac',
+                  title: 'Access Control',
+                  controls: [
+                    { id: 'AC-1', title: 'Access control policy' },
+                    { id: 'AC-2', title: 'Account management' },
+                  ],
+                },
+              ],
+            },
+          },
+        };
+      }
+      if (url === '/api/oscal/system-security-plans/ssp-1/profiles') {
+        return {
+          data: {
+            data: [{ uuid: 'profile-1', title: 'Moderate Baseline' }],
+          },
+        };
+      }
+      if (url === '/api/oscal/profiles/profile-1/resolved-with-catalogs') {
+        return {
+          data: {
+            data: [
+              {
+                controlId: 'AC-1',
+                title: 'Access control policy',
+                catalogId: 'catalog-1',
+              },
+              {
+                controlId: 'AC-2',
+                title: 'Account management',
+                catalogId: 'catalog-1',
+              },
+            ],
+          },
+        };
+      }
+      throw new Error(`Unexpected axios get: ${url}`);
+    });
+  });
+
+  it('groups pending suggestions by labelSetHash and expands reasoning', async () => {
+    const wrapper = mountView();
+
+    expect(wrapper.findAll('[data-testid^="suggestion-group-"]')).toHaveLength(
+      1,
+    );
+    expect(wrapper.text()).toContain('Production access');
+    expect(wrapper.text()).toContain('AC-1');
+    expect(wrapper.text()).toContain('_agent=scanner');
+    expect(wrapper.text()).toContain('env=prod');
+
+    const evidenceLink = wrapper.find('a[data-to]');
+    expect(evidenceLink.text()).toContain('7 matched evidence');
+    expect(JSON.parse(evidenceLink.attributes('data-to') ?? '{}')).toEqual({
+      name: 'evidence:index',
+      query: { filter: '_agent=scanner and env=prod' },
+    });
+
+    const reasoningButton = wrapper
+      .findAll('button')
+      .find((button) => button.text().includes('Reasoning'));
+    await reasoningButton?.trigger('click');
+    await nextTick();
+
+    expect(wrapper.text()).toContain('Fits AC-1');
+    expect(wrapper.text()).toContain('Relevant to payments');
+  });
+
+  it('wires group accept and reject reason payloads', async () => {
+    const wrapper = mountView();
+
+    await wrapper
+      .findAll('button')
+      .find((button) => button.text() === 'Accept group')
+      ?.trigger('click');
+    expect(state.acceptSuggestions).toHaveBeenCalledWith(['sug-1', 'sug-2']);
+
+    await wrapper
+      .findAll('button')
+      .find((button) => button.text() === 'Reject group')
+      ?.trigger('click');
+    await wrapper.find('textarea').setValue('Not useful');
+    await wrapper
+      .findAll('button')
+      .filter((button) => button.text() === 'Reject')
+      .at(-1)
+      ?.trigger('click');
+
+    expect(state.rejectSuggestions).toHaveBeenCalledWith(
+      ['sug-1', 'sug-2'],
+      'Not useful',
+    );
+  });
+
+  it('refreshes and polls suggestions when the config is enabled', async () => {
+    state.aiEnabled = true;
+    state.aiFetched = false;
+    state.fetchConfig.mockImplementation(async () => {
+      state.aiFetched = true;
+      return true;
+    });
+
+    mountView();
+    await flushPromises();
+
+    expect(state.refreshLabelSets).toHaveBeenCalled();
+    expect(state.refreshHistorySuggestions).toHaveBeenCalled();
+    expect(state.pollLatest).toHaveBeenCalled();
+  });
+
+  it('enriches scope control options with catalog titles and profile membership', async () => {
+    const wrapper = mountView();
+    await flushPromises();
+
+    const controls = wrapper
+      .findComponent(SuggestionScopeDialog)
+      .props('controls') as Array<{
+      label: string;
+      value: string;
+      controlId: string;
+      title: string;
+      catalogTitle: string;
+      profileTitles: string[];
+    }>;
+
+    expect(controls).toContainEqual({
+      label: 'ac-1 - Access control policy',
+      value: 'ac-1',
+      controlId: 'ac-1',
+      title: 'Access control policy',
+      catalogTitle: 'Catalog',
+      profileTitles: ['Moderate Baseline'],
+    });
+    expect(controls).toContainEqual({
+      label: 'AC-2 - Account management',
+      value: 'AC-2',
+      controlId: 'AC-2',
+      title: 'Account management',
+      catalogTitle: 'Catalog',
+      profileTitles: ['Moderate Baseline'],
+    });
+    expect(state.axiosGet).not.toHaveBeenCalledWith(
+      '/api/oscal/catalogs/catalog-1/full',
+    );
+  });
+
+  it('does not poll or refresh suggestions when the config is disabled', async () => {
+    state.aiEnabled = false;
+    state.aiFetched = false;
+    state.fetchConfig.mockImplementation(async () => {
+      state.aiFetched = true;
+      return false;
+    });
+
+    const wrapper = mountView();
+    await flushPromises();
+    await wrapper.vm.$forceUpdate();
+    await nextTick();
+
+    expect(wrapper.text()).toContain(
+      'AI is not configured, so dashboard suggestions cannot be generated.',
+    );
+    expect(state.refreshLabelSets).not.toHaveBeenCalled();
+    expect(state.refreshHistorySuggestions).not.toHaveBeenCalled();
+    expect(state.pollLatest).not.toHaveBeenCalled();
+    expect(state.start).not.toHaveBeenCalled();
+  });
+});
diff --git a/src/views/dashboard/partials/SuggestionScopeDialog.vue b/src/views/dashboard/partials/SuggestionScopeDialog.vue
new file mode 100644
index 00000000..6838a414
--- /dev/null
+++ b/src/views/dashboard/partials/SuggestionScopeDialog.vue
@@ -0,0 +1,374 @@
+<template>
+  <Dialog
+    v-model:visible="modelVisible"
+    modal
+    header="Generate suggestions"
+    size="lg"
+  >
+    <div class="flex flex-col gap-5">
+      <div>
+        <label class="inline-block pb-2">Controls</label>
+        <MultiSelect
+          v-model="selectedControls"
+          :options="controls"
+          optionLabel="label"
+          optionValue="value"
+          display="chip"
+          filter
+          class="w-full"
+          placeholder="All controls"
+        >
+          <template #option="{ option }">
+            <div class="flex flex-col gap-1">
+              <div class="flex flex-wrap items-center gap-2">
+                <span class="font-medium">
+                  {{
+                    option.controlId && option.title
+                      ? `${option.controlId} - ${option.title}`
+                      : option.label
+                  }}
+                </span>
+                <Chip
+                  v-for="profileTitle in option.profileTitles ?? []"
+                  :key="profileTitle"
+                  :label="profileTitle"
+                />
+              </div>
+              <span
+                v-if="option.catalogTitle"
+                class="text-xs text-gray-500 dark:text-slate-400"
+              >
+                {{ option.catalogTitle }}
+              </span>
+            </div>
+          </template>
+        </MultiSelect>
+      </div>
+
+      <div>
+        <label class="inline-block pb-2">Evidence label sets</label>
+        <MultiSelect
+          v-model="selectedLabelSetHashes"
+          :options="labelSetOptions"
+          optionLabel="title"
+          optionValue="hash"
+          display="chip"
+          filter
+          class="w-full"
+          placeholder="All label sets"
+        >
+          <template #option="{ option }">
+            <div class="flex flex-col gap-1">
+              <span class="font-medium">
+                {{ option.title || getLabelSetTitle(option) }}
+              </span>
+              <div
+                class="flex flex-wrap items-center gap-2 text-xs text-gray-500 dark:text-slate-400"
+              >
+                <Chip
+                  v-for="label in option.displayLabels"
+                  :key="label"
+                  :label="label"
+                />
+                <span v-if="option.hiddenLabelCount > 0">
+                  {{ option.hiddenLabelCount }} more
+                  {{ option.hiddenLabelCount === 1 ? 'label' : 'labels' }}
+                </span>
+              </div>
+            </div>
+          </template>
+        </MultiSelect>
+      </div>
+
+      <label class="flex items-center gap-2">
+        <Checkbox v-model="supersedePending" binary />
+        <span>Replace pending suggestions in this scope</span>
+      </label>
+
+      <Message
+        v-if="scopeError"
+        severity="error"
+        variant="outlined"
+        data-testid="scope-ceiling"
+      >
+        {{ scopeError }}
+      </Message>
+      <Message
+        v-else-if="previewLoading || !preview"
+        severity="info"
+        variant="outlined"
+      >
+        Loading suggestion estimate.
+      </Message>
+      <Message
+        v-else-if="requiresLargeRunConfirm"
+        severity="warn"
+        variant="outlined"
+        data-testid="scope-warning"
+      >
+        This will make {{ preview.plannedCalls }} AI calls covering
+        {{ preview.controlCount }} controls x {{ preview.labelSetCount }}
+        label-sets. These run as queued background jobs and may take a while and
+        incur API costs.
+      </Message>
+      <Message v-else severity="info" variant="outlined">
+        {{ preview.plannedCalls }} AI calls covering
+        {{ preview.controlCount }} controls x {{ preview.labelSetCount }}
+        label-sets.
+      </Message>
+
+      <label
+        v-if="requiresLargeRunConfirm"
+        class="flex items-center gap-2"
+        data-testid="scope-confirm-large"
+      >
+        <Checkbox v-model="largeRunConfirmed" binary />
+        <span>Confirm this larger generation run</span>
+      </label>
+    </div>
+
+    <template #footer>
+      <SecondaryButton @click="modelVisible = false">Cancel</SecondaryButton>
+      <PrimaryButton
+        :disabled="!canGenerate || generating"
+        @click="submit"
+        data-testid="scope-generate"
+      >
+        Generate
+      </PrimaryButton>
+    </template>
+  </Dialog>
+</template>
+
+<script setup lang="ts">
+import { computed, onUnmounted, ref, watch } from 'vue';
+import Checkbox from 'primevue/checkbox';
+import Chip from '@/volt/Chip.vue';
+import Dialog from '@/volt/Dialog.vue';
+import Message from '@/volt/Message.vue';
+import MultiSelect from '@/volt/MultiSelect.vue';
+import { useAuthenticatedInstance } from '@/composables/axios';
+import type {
+  DashboardSuggestionsPreview,
+  DashboardSuggestionLabelSet,
+  GenerateDashboardSuggestionsPayload,
+} from './dashboard-suggestions';
+import {
+  buildPreviewDashboardSuggestionsEndpoint,
+  formatVisibleLabelSet,
+} from './dashboard-suggestions';
+import type { DataResponse } from '@/stores/types';
+
+interface ControlOption {
+  label: string;
+  value: string;
+  controlId?: string;
+  title?: string;
+  catalogTitle?: string;
+  profileTitles?: string[];
+}
+
+type LabelSetOption = DashboardSuggestionLabelSet & {
+  title: string;
+  displayLabels: string[];
+  hiddenLabelCount: number;
+};
+
+// Max non-internal labels shown per label set before collapsing into a count.
+const MAX_VISIBLE_LABELS = 5;
+
+const props = defineProps<{
+  visible: boolean;
+  sspId: string;
+  controls: ControlOption[];
+  labelSets: DashboardSuggestionLabelSet[];
+  generating?: boolean;
+  ceilingError?: string;
+}>();
+
+const emit = defineEmits<{
+  'update:visible': [visible: boolean];
+  'scope-change': [];
+  generate: [payload: GenerateDashboardSuggestionsPayload];
+}>();
+
+const selectedControls = ref<string[]>([]);
+const selectedLabelSetHashes = ref<string[]>([]);
+const supersedePending = ref(true);
+const largeRunConfirmed = ref(false);
+const preview = ref<DashboardSuggestionsPreview | null>(null);
+const previewLoading = ref(false);
+const previewError = ref('');
+const warningThreshold = 25;
+const axios = useAuthenticatedInstance();
+let previewTimer: ReturnType<typeof setTimeout> | undefined;
+let latestPreviewRequestId = 0;
+
+const modelVisible = computed({
+  get: () => props.visible,
+  set: (visible: boolean) => emit('update:visible', visible),
+});
+
+const requiresLargeRunConfirm = computed(
+  () => (preview.value?.plannedCalls ?? 0) > warningThreshold,
+);
+const scopeError = computed(() => props.ceilingError || previewError.value);
+const canGenerate = computed(
+  () =>
+    !!preview.value &&
+    preview.value.plannedCalls > 0 &&
+    !previewLoading.value &&
+    !scopeError.value &&
+    (!requiresLargeRunConfirm.value || largeRunConfirmed.value),
+);
+const labelSetOptions = computed<LabelSetOption[]>(() =>
+  props.labelSets.map((labelSet) => {
+    const visibleLabels = formatVisibleLabelSet(labelSet.labels ?? {});
+    return {
+      ...labelSet,
+      title: getLabelSetTitle(labelSet),
+      displayLabels: visibleLabels.slice(0, MAX_VISIBLE_LABELS),
+      hiddenLabelCount: Math.max(0, visibleLabels.length - MAX_VISIBLE_LABELS),
+    };
+  }),
+);
+
+watch(
+  () => props.controls,
+  (controls) => {
+    selectedControls.value = controls.map((control) => control.value);
+  },
+  { immediate: true },
+);
+
+watch(
+  () => props.labelSets,
+  (labelSets) => {
+    selectedLabelSetHashes.value = labelSets.map((labelSet) => labelSet.hash);
+  },
+  { immediate: true },
+);
+
+watch(
+  [selectedControls, selectedLabelSetHashes],
+  () => {
+    largeRunConfirmed.value = false;
+    previewError.value = '';
+    emit('scope-change');
+    schedulePreview();
+  },
+  { deep: true },
+);
+
+watch(
+  [modelVisible],
+  () => {
+    largeRunConfirmed.value = false;
+    schedulePreview();
+  },
+  { immediate: true },
+);
+
+watch(
+  () => props.sspId,
+  () => {
+    schedulePreview();
+  },
+);
+
+watch([() => props.controls, () => props.labelSets], () => {
+  schedulePreview();
+});
+
+function selectedScope(): GenerateDashboardSuggestionsPayload['scope'] {
+  const scope: GenerateDashboardSuggestionsPayload['scope'] = {};
+  if (selectedControls.value.length !== props.controls.length) {
+    scope.controlKeys = selectedControls.value;
+  }
+  if (selectedLabelSetHashes.value.length !== props.labelSets.length) {
+    scope.labelSetHashes = selectedLabelSetHashes.value;
+  }
+  return Object.keys(scope).length > 0 ? scope : undefined;
+}
+
+function submit() {
+  if (!canGenerate.value) {
+    return;
+  }
+  emit('generate', {
+    supersedePending: supersedePending.value,
+    scope: selectedScope(),
+  });
+}
+
+function schedulePreview() {
+  const requestId = latestPreviewRequestId + 1;
+  latestPreviewRequestId = requestId;
+
+  if (previewTimer) {
+    clearTimeout(previewTimer);
+  }
+  preview.value = null;
+  previewError.value = '';
+
+  if (!modelVisible.value || !props.sspId) {
+    previewLoading.value = false;
+    return;
+  }
+
+  previewLoading.value = true;
+  previewTimer = setTimeout(() => {
+    void fetchPreview(requestId);
+  }, 250);
+}
+
+onUnmounted(() => {
+  if (previewTimer) {
+    clearTimeout(previewTimer);
+  }
+});
+
+async function fetchPreview(requestId: number) {
+  try {
+    const scope = selectedScope();
+    const response = await axios.post<
+      DataResponse<DashboardSuggestionsPreview>
+    >(
+      buildPreviewDashboardSuggestionsEndpoint(props.sspId),
+      scope ? { scope } : {},
+    );
+    if (requestId !== latestPreviewRequestId) {
+      return;
+    }
+    preview.value = response.data.data;
+    previewError.value = '';
+  } catch (error) {
+    if (requestId !== latestPreviewRequestId) {
+      return;
+    }
+    const status = (error as { response?: { status?: number } }).response
+      ?.status;
+    preview.value = null;
+    previewError.value =
+      status === 422
+        ? 'The selected scope does not include any controls or label sets.'
+        : 'Unable to preview the selected suggestion scope.';
+  } finally {
+    if (requestId === latestPreviewRequestId) {
+      previewLoading.value = false;
+    }
+  }
+}
+
+function getLabelSetTitle(labelSet: DashboardSuggestionLabelSet) {
+  const sampleTitle = labelSet.sampleTitles?.find(
+    (title) => title.trim().length > 0,
+  );
+  if (sampleTitle) {
+    return sampleTitle;
+  }
+
+  const labelSummary = formatVisibleLabelSet(labelSet.labels ?? {}).join(', ');
+  return labelSummary || labelSet.hash;
+}
+</script>
diff --git a/src/views/dashboard/partials/__tests__/SuggestionScopeDialog.spec.ts b/src/views/dashboard/partials/__tests__/SuggestionScopeDialog.spec.ts
new file mode 100644
index 00000000..699fc531
--- /dev/null
+++ b/src/views/dashboard/partials/__tests__/SuggestionScopeDialog.spec.ts
@@ -0,0 +1,286 @@
+import { flushPromises, mount } from '@vue/test-utils';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import SuggestionScopeDialog from '../SuggestionScopeDialog.vue';
+import type { DashboardSuggestionLabelSet } from '../dashboard-suggestions';
+
+const state = vi.hoisted(() => ({
+  axiosPost: vi.fn(),
+  preview: {
+    plannedCalls: undefined as number | undefined,
+    controlCount: undefined as number | undefined,
+    labelSetCount: undefined as number | undefined,
+  },
+}));
+
+vi.mock('@/composables/axios', () => ({
+  useAuthenticatedInstance: () => ({ post: state.axiosPost }),
+}));
+
+function makeLabelSet(hash: string): DashboardSuggestionLabelSet {
+  return {
+    hash,
+    labels: { env: hash },
+    evidenceCount: 2,
+  };
+}
+
+function mountDialog(props = {}) {
+  return mount(SuggestionScopeDialog, {
+    props: {
+      visible: true,
+      sspId: 'ssp-1',
+      controls: [
+        {
+          label: 'AC-1 - Access control policy',
+          value: 'AC-1',
+          controlId: 'AC-1',
+          title: 'Access control policy',
+          catalogTitle: 'NIST SP 800-53 Rev 5',
+          profileTitles: ['Moderate Baseline'],
+        },
+        { label: 'AC-2', value: 'AC-2' },
+      ],
+      labelSets: [makeLabelSet('hash-1'), makeLabelSet('hash-2')],
+      ...props,
+    },
+    global: {
+      stubs: {
+        Dialog: { template: '<div><slot /><slot name="footer" /></div>' },
+        Chip: { props: ['label'], template: '<span>{{ label }}</span>' },
+        Message: { template: '<div><slot /></div>' },
+        MultiSelect: {
+          name: 'MultiSelect',
+          props: ['modelValue', 'options', 'optionLabel', 'optionValue'],
+          emits: ['update:modelValue'],
+          template:
+            '<div><div v-for="option in options" :key="option[optionValue]"><slot name="option" :option="option">{{ option[optionLabel] }}</slot></div></div>',
+        },
+        Checkbox: {
+          name: 'Checkbox',
+          props: ['modelValue'],
+          emits: ['update:modelValue'],
+          template:
+            '<input type="checkbox" :checked="modelValue" @change="$emit(\'update:modelValue\', true)" />',
+        },
+        PrimaryButton: {
+          props: ['disabled'],
+          template:
+            '<button :disabled="disabled" @click="$emit(\'click\')"><slot /></button>',
+        },
+        SecondaryButton: {
+          template: '<button @click="$emit(\'click\')"><slot /></button>',
+        },
+      },
+    },
+  });
+}
+
+async function flushPreview() {
+  await flushPromises();
+  await vi.runOnlyPendingTimersAsync();
+  await flushPromises();
+}
+
+describe('SuggestionScopeDialog', () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    vi.clearAllMocks();
+    state.preview = {
+      plannedCalls: undefined,
+      controlCount: undefined,
+      labelSetCount: undefined,
+    };
+    state.axiosPost.mockImplementation(async (_url: string, body: unknown) => {
+      const scope = (
+        body as {
+          scope?: { controlKeys?: string[]; labelSetHashes?: string[] };
+        }
+      )?.scope;
+      const controlCount =
+        state.preview.controlCount ?? scope?.controlKeys?.length ?? 2;
+      const labelSetCount =
+        state.preview.labelSetCount ?? scope?.labelSetHashes?.length ?? 2;
+      return {
+        data: {
+          data: {
+            plannedCalls:
+              state.preview.plannedCalls ?? controlCount * labelSetCount,
+            controlCount,
+            labelSetCount,
+          },
+        },
+      };
+    });
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it('updates the live cost preview when scope selections change', async () => {
+    const wrapper = mountDialog();
+    await flushPreview();
+    expect(wrapper.text()).toContain('4 AI calls covering 2 controls x 2');
+
+    await wrapper
+      .findAllComponents({ name: 'MultiSelect' })[0]
+      .vm.$emit('update:modelValue', ['AC-1']);
+    await flushPreview();
+
+    expect(wrapper.text()).toContain('2 AI calls covering 1 controls x 2');
+  });
+
+  it('requires explicit confirmation for larger grids', async () => {
+    state.preview = {
+      plannedCalls: 30,
+      controlCount: 6,
+      labelSetCount: 5,
+    };
+    const wrapper = mountDialog({
+      controls: Array.from({ length: 6 }, (_, index) => ({
+        label: `AC-${index}`,
+        value: `AC-${index}`,
+      })),
+      labelSets: Array.from({ length: 5 }, (_, index) =>
+        makeLabelSet(`hash-${index}`),
+      ),
+    });
+    await flushPreview();
+
+    expect(wrapper.text()).toContain('This will make 30 AI calls');
+    expect(
+      wrapper.find('[data-testid="scope-generate"]').attributes('disabled'),
+    ).toBeDefined();
+
+    await wrapper
+      .findAllComponents({ name: 'Checkbox' })[1]
+      .vm.$emit('update:modelValue', true);
+    await wrapper.find('[data-testid="scope-generate"]').trigger('click');
+
+    expect(wrapper.emitted('generate')?.at(-1)).toEqual([
+      {
+        supersedePending: true,
+        scope: undefined,
+      },
+    ]);
+  });
+
+  it('surfaces the configured ceiling inline and blocks submission', async () => {
+    const wrapper = mountDialog({ ceilingError: 'Maximum is 10 calls' });
+    await flushPreview();
+
+    expect(wrapper.find('[data-testid="scope-ceiling"]').text()).toContain(
+      'Maximum is 10 calls',
+    );
+    await wrapper.find('[data-testid="scope-generate"]').trigger('click');
+    expect(wrapper.emitted('generate')).toBeUndefined();
+  });
+
+  it('emits scope-change when the selected scope changes', async () => {
+    const wrapper = mountDialog({ ceilingError: 'Maximum is 10 calls' });
+    await flushPreview();
+
+    await wrapper
+      .findAllComponents({ name: 'MultiSelect' })[0]
+      .vm.$emit('update:modelValue', ['AC-1']);
+
+    expect(wrapper.emitted('scope-change')).toBeTruthy();
+  });
+
+  it('renders controls with catalog and profile metadata in dropdown options', () => {
+    const wrapper = mountDialog();
+    const controlSelector = wrapper.findAllComponents({
+      name: 'MultiSelect',
+    })[0];
+
+    expect(controlSelector.text()).toContain('AC-1 - Access control policy');
+    expect(controlSelector.text()).toContain('NIST SP 800-53 Rev 5');
+    expect(controlSelector.text()).toContain('Moderate Baseline');
+  });
+
+  it('clears the pending preview timer on unmount', async () => {
+    const wrapper = mountDialog();
+
+    wrapper.unmount();
+    await vi.runOnlyPendingTimersAsync();
+
+    expect(state.axiosPost).not.toHaveBeenCalled();
+  });
+
+  it('uses preview planned calls for large-run confirmation instead of local cartesian size', async () => {
+    state.preview = {
+      plannedCalls: 1,
+      controlCount: 16,
+      labelSetCount: 89,
+    };
+    const wrapper = mountDialog({
+      controls: Array.from({ length: 16 }, (_, index) => ({
+        label: `AC-${index}`,
+        value: `AC-${index}`,
+      })),
+      labelSets: Array.from({ length: 89 }, (_, index) =>
+        makeLabelSet(`hash-${index}`),
+      ),
+    });
+    await flushPreview();
+
+    expect(wrapper.text()).toContain('1 AI calls covering 16 controls x 89');
+    expect(wrapper.find('[data-testid="scope-confirm-large"]').exists()).toBe(
+      false,
+    );
+
+    await wrapper.find('[data-testid="scope-generate"]').trigger('click');
+    expect(wrapper.emitted('generate')?.at(-1)).toEqual([
+      {
+        supersedePending: true,
+        scope: undefined,
+      },
+    ]);
+  });
+
+  it('blocks generation when preview returns an empty resolved scope', async () => {
+    state.axiosPost.mockRejectedValueOnce({ response: { status: 422 } });
+    const wrapper = mountDialog();
+    await flushPreview();
+
+    expect(wrapper.find('[data-testid="scope-ceiling"]').text()).toContain(
+      'The selected scope does not include any controls or label sets.',
+    );
+    await wrapper.find('[data-testid="scope-generate"]').trigger('click');
+    expect(wrapper.emitted('generate')).toBeUndefined();
+  });
+
+  it('shows human label-set titles instead of selected hash labels', () => {
+    const wrapper = mountDialog({
+      labelSets: [
+        {
+          hash: 'opaque-hash',
+          labels: { env: 'prod', service: 'payments' },
+          evidenceCount: 2,
+          sampleTitles: ['Payment evidence'],
+        },
+        {
+          hash: 'fallback-hash',
+          labels: { env: 'stage' },
+          evidenceCount: 1,
+        },
+      ],
+    });
+
+    const labelSetSelector = wrapper.findAllComponents({
+      name: 'MultiSelect',
+    })[1];
+    const labelSetOptions = labelSetSelector.props('options') as Array<{
+      title: string;
+    }>;
+
+    expect(labelSetOptions.map((option) => option.title)).toEqual([
+      'Payment evidence',
+      'env=stage',
+    ]);
+    expect(labelSetSelector.text()).toContain('Payment evidence');
+    expect(labelSetSelector.text()).toContain('env=prod');
+    // Evidence counts are no longer rendered (label sets are 1-for-1 with evidence).
+    expect(labelSetSelector.text()).not.toContain('2 evidence');
+  });
+});
diff --git a/src/views/dashboard/partials/dashboard-suggestions.ts b/src/views/dashboard/partials/dashboard-suggestions.ts
new file mode 100644
index 00000000..4cc16854
--- /dev/null
+++ b/src/views/dashboard/partials/dashboard-suggestions.ts
@@ -0,0 +1,160 @@
+export type DashboardSuggestionStatus =
+  | 'pending'
+  | 'accepted'
+  | 'rejected'
+  | 'superseded';
+
+export type SuggestionRunStatus =
+  | 'idle'
+  | 'pending'
+  | 'running'
+  | 'completed'
+  | 'failed';
+
+export interface DashboardSuggestionLabelSet {
+  hash: string;
+  labels: Record<string, string>;
+  evidenceCount: number;
+  sampleTitles?: string[];
+}
+
+export interface DashboardSuggestionScope {
+  controlKeys?: string[];
+  labelSetHashes?: string[];
+}
+
+export interface GenerateDashboardSuggestionsPayload {
+  supersedePending?: boolean;
+  scope?: DashboardSuggestionScope;
+}
+
+export interface DashboardSuggestionsPreview {
+  plannedCalls: number;
+  controlCount: number;
+  labelSetCount: number;
+}
+
+export interface SuggestionRunFailure {
+  controlKey?: string;
+  labelSetHash?: string;
+  message?: string;
+}
+
+export interface SuggestionRun {
+  id?: string;
+  uuid?: string;
+  status: SuggestionRunStatus;
+  plannedCalls: number;
+  completedCells: number;
+  failedCells: number;
+  scope?: DashboardSuggestionScope;
+  error?: string;
+  failures?: SuggestionRunFailure[];
+  createdAt?: string;
+  updatedAt?: string;
+}
+
+export interface DashboardSuggestion {
+  id: string;
+  uuid?: string;
+  status: DashboardSuggestionStatus;
+  controlId: string;
+  controlTitle?: string;
+  labelSetHash: string;
+  labelSet?: Record<string, string>;
+  labels?: Record<string, string>;
+  confidence?: number;
+  reasoning?: string;
+  controlFitReasoning?: string;
+  systemRelevanceReasoning?: string;
+  action?: 'create' | 'extend';
+  proposedFilterName?: string;
+  targetFilterId?: string;
+  targetFilterName?: string;
+  evidenceCount?: number;
+  createdAt?: string;
+  updatedAt?: string;
+}
+
+export interface DashboardSuggestionEvent {
+  id?: string;
+  uuid?: string;
+  action?: string;
+  actor?: string;
+  reasoning?: string;
+  resultingFilterId?: string;
+  resultingFilterName?: string;
+  createdAt?: string;
+}
+
+export function dashboardSuggestionsBaseEndpoint(sspId: string): string {
+  return `/api/oscal/system-security-plans/${encodeURIComponent(sspId)}`;
+}
+
+export function buildDashboardSuggestionsConfigEndpoint(): string {
+  return '/api/dashboard-suggestions/config';
+}
+
+export function buildGenerateDashboardSuggestionsEndpoint(
+  sspId: string,
+): string {
+  return `${dashboardSuggestionsBaseEndpoint(sspId)}/dashboard-suggestions/generate`;
+}
+
+export function buildPreviewDashboardSuggestionsEndpoint(
+  sspId: string,
+): string {
+  return `${dashboardSuggestionsBaseEndpoint(sspId)}/dashboard-suggestions/preview`;
+}
+
+export function buildDashboardSuggestionLabelSetsEndpoint(
+  sspId: string,
+): string {
+  return `${dashboardSuggestionsBaseEndpoint(sspId)}/dashboard-suggestions/label-sets`;
+}
+
+export function buildLatestDashboardSuggestionRunEndpoint(
+  sspId: string,
+): string {
+  return `${dashboardSuggestionsBaseEndpoint(sspId)}/dashboard-suggestion-runs/latest`;
+}
+
+export function buildDashboardSuggestionsEndpoint(
+  sspId: string,
+  status?: string,
+): string {
+  const query = status ? `?status=${encodeURIComponent(status)}` : '';
+  return `${dashboardSuggestionsBaseEndpoint(sspId)}/dashboard-suggestions${query}`;
+}
+
+export function buildAcceptDashboardSuggestionsEndpoint(sspId: string): string {
+  return `${dashboardSuggestionsBaseEndpoint(sspId)}/dashboard-suggestions/accept`;
+}
+
+export function buildRejectDashboardSuggestionsEndpoint(sspId: string): string {
+  return `${dashboardSuggestionsBaseEndpoint(sspId)}/dashboard-suggestions/reject`;
+}
+
+export function buildDashboardSuggestionEventsEndpoint(
+  sspId: string,
+  suggestionId: string,
+): string {
+  return `${dashboardSuggestionsBaseEndpoint(sspId)}/dashboard-suggestions/${encodeURIComponent(suggestionId)}/events`;
+}
+
+export function formatLabelSet(labels: Record<string, string>): string[] {
+  return Object.entries(labels).map(([key, value]) => `${key}=${value}`);
+}
+
+// Labels whose key starts with `_` are internal and hidden from the UI.
+export function formatVisibleLabelSet(
+  labels: Record<string, string>,
+): string[] {
+  return Object.entries(labels)
+    .filter(([key]) => !key.startsWith('_'))
+    .map(([key, value]) => `${key}=${value}`);
+}
+
+export function isRunActive(run: SuggestionRun | undefined): boolean {
+  return run?.status === 'pending' || run?.status === 'running';
+}