@agent-relay/dashboard 2.0.82 → 2.0.84

package/src/components/settings/SettingsPage.tsx

@@ -11,18 +11,17 @@
  */
 
 import React, { useState, useEffect, useCallback } from 'react';
-import { cloudApi, getCsrfToken } from '../../lib/cloudApi';
-import { WorkspaceSettingsPanel } from './WorkspaceSettingsPanel';
-import { TeamSettingsPanel } from './TeamSettingsPanel';
-import { BillingSettingsPanel } from './BillingSettingsPanel';
+import { useDashboardConfig, type DashboardFeatures } from '../../adapters';
 import type { Settings, CliType } from './types';
-import { CLAUDE_MODEL_OPTIONS, CURSOR_MODEL_OPTIONS, CODEX_MODEL_OPTIONS, GEMINI_MODEL_OPTIONS } from '../SpawnModal';
+import { type ModelOption, DEFAULT_MODEL_OPTIONS } from '../SpawnModal';
+
+type SettingsTab = 'dashboard' | 'workspace' | 'team' | 'billing';
 
 export interface SettingsPageProps {
   /** Current user ID for team membership checks */
   currentUserId?: string;
   /** Initial tab to show */
-  initialTab?: 'dashboard' | 'workspace' | 'team' | 'billing';
+  initialTab?: SettingsTab;
   /** Callback when settings page is closed */
   onClose?: () => void;
   /** Current dashboard settings */
@@ -33,6 +32,13 @@ export interface SettingsPageProps {
   activeWorkspaceId?: string | null;
   /** Callback when repos are added/removed in workspace settings */
   onReposChanged?: () => void;
+  /** Model options per agent type — provided by the host app */
+  modelOptions?: {
+    claude?: ModelOption[];
+    cursor?: ModelOption[];
+    codex?: ModelOption[];
+    gemini?: ModelOption[];
+  };
 }
 
 interface WorkspaceSummary {
@@ -41,21 +47,49 @@ interface WorkspaceSummary {
   status: string;
 }
 
+function isTabEnabled(tab: SettingsTab, features: DashboardFeatures): boolean {
+  if (tab === 'workspace') return features.workspaces;
+  if (tab === 'team') return features.teams;
+  if (tab === 'billing') return features.billing;
+  return true;
+}
+
+function resolveInitialTab(initialTab: SettingsTab, features: DashboardFeatures): SettingsTab {
+  return isTabEnabled(initialTab, features) ? initialTab : 'dashboard';
+}
+
+const EMPTY_MODEL_OPTIONS: ModelOption[] = [];
+
 export function SettingsPage({
-  currentUserId,
   initialTab = 'dashboard',
   onClose,
   settings,
   onUpdateSettings,
   activeWorkspaceId,
-  onReposChanged,
+  modelOptions,
 }: SettingsPageProps) {
-  const [activeTab, setActiveTab] = useState<'dashboard' | 'workspace' | 'team' | 'billing'>(initialTab);
+  const config = useDashboardConfig();
+  const { features, api, settingsSlots } = config;
+
+  const claudeModels = modelOptions?.claude ?? DEFAULT_MODEL_OPTIONS.claude ?? EMPTY_MODEL_OPTIONS;
+  const cursorModels = modelOptions?.cursor ?? DEFAULT_MODEL_OPTIONS.cursor ?? EMPTY_MODEL_OPTIONS;
+  const codexModels = modelOptions?.codex ?? DEFAULT_MODEL_OPTIONS.codex ?? EMPTY_MODEL_OPTIONS;
+  const geminiModels = modelOptions?.gemini ?? DEFAULT_MODEL_OPTIONS.gemini ?? EMPTY_MODEL_OPTIONS;
+
+  const [activeTab, setActiveTab] = useState<SettingsTab>(() =>
+    resolveInitialTab(initialTab, features)
+  );
   const [workspaces, setWorkspaces] = useState<WorkspaceSummary[]>([]);
   // Initialize with activeWorkspaceId from parent if provided
   const [selectedWorkspaceId, setSelectedWorkspaceId] = useState<string | null>(activeWorkspaceId ?? null);
   const [isLoadingWorkspaces, setIsLoadingWorkspaces] = useState(true);
 
+  useEffect(() => {
+    if (!isTabEnabled(activeTab, features)) {
+      setActiveTab('dashboard');
+    }
+  }, [activeTab, features.billing, features.teams, features.workspaces]);
+
   // Sync selectedWorkspaceId when activeWorkspaceId prop changes
   useEffect(() => {
     if (activeWorkspaceId) {
@@ -63,23 +97,49 @@ export function SettingsPage({
     }
   }, [activeWorkspaceId]);
 
-  // Load workspaces
+  // Load workspaces only when workspace features and API adapter are available.
   useEffect(() => {
+    const apiAdapter = api;
+
+    if (!features.workspaces || !apiAdapter) {
+      setIsLoadingWorkspaces(false);
+      setWorkspaces([]);
+      return;
+    }
+
+    const workspaceApi = apiAdapter;
+    let cancelled = false;
+
     async function loadWorkspaces() {
       setIsLoadingWorkspaces(true);
-      const result = await cloudApi.getWorkspaceSummary();
+      const result = await workspaceApi.getWorkspaceSummary();
+
+      if (cancelled) {
+        return;
+      }
+
       if (result.success && result.data.workspaces.length > 0) {
-        setWorkspaces(result.data.workspaces);
+        const summaries = result.data.workspaces.map((workspace) => ({
+          id: workspace.id,
+          name: workspace.name,
+          status: workspace.status,
+        }));
+        setWorkspaces(summaries);
         // Only auto-select first workspace if no workspace is selected
         // (either from prop or previous user selection)
-        if (!selectedWorkspaceId) {
-          setSelectedWorkspaceId(result.data.workspaces[0].id);
-        }
+        setSelectedWorkspaceId((prev) => prev ?? summaries[0].id);
+      } else {
+        setWorkspaces([]);
       }
       setIsLoadingWorkspaces(false);
     }
+
     loadWorkspaces();
-  }, [selectedWorkspaceId]);
+
+    return () => {
+      cancelled = true;
+    };
+  }, [api, features.workspaces]);
 
   const updateSettings = useCallback((updater: (prev: Settings) => Settings) => {
     onUpdateSettings(updater);
@@ -98,13 +158,19 @@ export function SettingsPage({
     });
   }, [updateSettings]);
 
-  const tabs = [
+  const allTabs = [
     { id: 'dashboard', label: 'Dashboard', icon: <DashboardIcon /> },
     { id: 'workspace', label: 'Workspace', icon: <WorkspaceIcon /> },
     { id: 'team', label: 'Team', icon: <TeamIcon /> },
     { id: 'billing', label: 'Billing', icon: <BillingIcon /> },
   ] as const;
 
+  const tabs = allTabs.filter((tab) => isTabEnabled(tab.id, features));
+
+  const BillingPanelSlot = settingsSlots?.BillingPanel;
+  const TeamPanelSlot = settingsSlots?.TeamPanel;
+  const WorkspacePanelSlot = settingsSlots?.WorkspacePanel;
+
   return (
     <div className="fixed inset-0 z-[1100] bg-bg-deep">
       {/* Background Pattern */}
@@ -328,7 +394,7 @@ export function SettingsPage({
                       description="Default model when spawning Claude agents"
                     >
                       <select
-                        value={settings.agentDefaults?.defaultModels?.claude ?? 'sonnet'}
+                        value={settings.agentDefaults?.defaultModels?.claude ?? claudeModels[0]?.value ?? ''}
                         onChange={(e) => updateSettings((prev) => ({
                           ...prev,
                           agentDefaults: {
@@ -341,7 +407,7 @@ export function SettingsPage({
                         }))}
                         className="px-4 py-2 bg-bg-tertiary border border-border-subtle rounded-lg text-sm text-text-primary focus:outline-none focus:border-accent-cyan"
                       >
-                        {CLAUDE_MODEL_OPTIONS.map((model) => (
+                        {claudeModels.map((model) => (
                           <option key={model.value} value={model.value}>{model.label}</option>
                         ))}
                       </select>
@@ -352,7 +418,7 @@ export function SettingsPage({
                       description="Default model when spawning Cursor agents"
                     >
                       <select
-                        value={settings.agentDefaults?.defaultModels?.cursor ?? 'opus-4.5-thinking'}
+                        value={settings.agentDefaults?.defaultModels?.cursor ?? cursorModels[0]?.value ?? ''}
                         onChange={(e) => updateSettings((prev) => ({
                           ...prev,
                           agentDefaults: {
@@ -365,7 +431,7 @@ export function SettingsPage({
                         }))}
                         className="px-4 py-2 bg-bg-tertiary border border-border-subtle rounded-lg text-sm text-text-primary focus:outline-none focus:border-accent-cyan"
                       >
-                        {CURSOR_MODEL_OPTIONS.map((model) => (
+                        {cursorModels.map((model) => (
                           <option key={model.value} value={model.value}>{model.label}</option>
                         ))}
                       </select>
@@ -376,7 +442,7 @@ export function SettingsPage({
                       description="Default model when spawning Codex agents"
                     >
                       <select
-                        value={settings.agentDefaults?.defaultModels?.codex ?? 'gpt-5.2-codex'}
+                        value={settings.agentDefaults?.defaultModels?.codex ?? codexModels[0]?.value ?? ''}
                         onChange={(e) => updateSettings((prev) => ({
                           ...prev,
                           agentDefaults: {
@@ -389,7 +455,7 @@ export function SettingsPage({
                         }))}
                         className="px-4 py-2 bg-bg-tertiary border border-border-subtle rounded-lg text-sm text-text-primary focus:outline-none focus:border-accent-cyan"
                       >
-                        {CODEX_MODEL_OPTIONS.map((model) => (
+                        {codexModels.map((model) => (
                           <option key={model.value} value={model.value}>{model.label}</option>
                         ))}
                       </select>
@@ -400,7 +466,7 @@ export function SettingsPage({
                       description="Default model when spawning Gemini agents"
                     >
                       <select
-                        value={settings.agentDefaults?.defaultModels?.gemini ?? 'gemini-2.5-pro'}
+                        value={settings.agentDefaults?.defaultModels?.gemini ?? geminiModels[0]?.value ?? ''}
                         onChange={(e) => updateSettings((prev) => ({
                           ...prev,
                           agentDefaults: {
@@ -413,7 +479,7 @@ export function SettingsPage({
                         }))}
                         className="px-4 py-2 bg-bg-tertiary border border-border-subtle rounded-lg text-sm text-text-primary focus:outline-none focus:border-accent-cyan"
                       >
-                        {GEMINI_MODEL_OPTIONS.map((model) => (
+                        {geminiModels.map((model) => (
                           <option key={model.value} value={model.value}>{model.label}</option>
                         ))}
                       </select>
@@ -432,23 +498,13 @@ export function SettingsPage({
                       </div>
                       <span className="ml-4 text-text-muted">Loading workspaces...</span>
                     </div>
-                  ) : selectedWorkspaceId ? (
-                    <WorkspaceSettingsPanel
-                      workspaceId={selectedWorkspaceId}
-                      csrfToken={getCsrfToken() || undefined}
-                      onClose={onClose}
-                      onReposChanged={onReposChanged}
-                    />
+                  ) : WorkspacePanelSlot ? (
+                    <WorkspacePanelSlot />
                   ) : (
                     <EmptyState
                       icon={<WorkspaceIcon />}
-                      title="No Workspace"
-                      description="Create a workspace to get started with Agent Relay."
-                      action={
-                        <button className="px-6 py-3 bg-accent-cyan text-bg-deep font-semibold rounded-lg hover:bg-accent-cyan/90 transition-colors">
-                          Create Workspace
-                        </button>
-                      }
+                      title="Workspace Settings Unavailable"
+                      description="A workspace settings panel has not been provided for this mode."
                     />
                   )}
                 </>
@@ -457,22 +513,19 @@ export function SettingsPage({
               {/* Team Settings */}
               {activeTab === 'team' && (
                 <>
-                  {selectedWorkspaceId ? (
+                  {TeamPanelSlot ? (
                     <div className="space-y-8">
                       <PageHeader
                         title="Team Settings"
                         subtitle="Manage workspace members and permissions"
                       />
-                      <TeamSettingsPanel
-                        workspaceId={selectedWorkspaceId}
-                        currentUserId={currentUserId}
-                      />
+                      <TeamPanelSlot />
                     </div>
                   ) : (
                     <EmptyState
                       icon={<TeamIcon />}
-                      title="No Workspace Selected"
-                      description="Select a workspace to manage team members."
+                      title="Team Settings Unavailable"
+                      description="A team settings panel has not been provided for this mode."
                     />
                   )}
                 </>
@@ -485,7 +538,15 @@ export function SettingsPage({
                     title="Billing & Subscription"
                     subtitle="Manage your plan and payment methods"
                   />
-                  <BillingSettingsPanel />
+                  {BillingPanelSlot ? (
+                    <BillingPanelSlot />
+                  ) : (
+                    <EmptyState
+                      icon={<BillingIcon />}
+                      title="Billing Settings Unavailable"
+                      description="A billing settings panel has not been provided for this mode."
+                    />
+                  )}
                 </div>
               )}
             </div>

package/src/components/settings/index.ts

@@ -5,7 +5,4 @@
  */
 
 export { SettingsPage, type SettingsPageProps } from './SettingsPage';
-export { WorkspaceSettingsPanel, type WorkspaceSettingsPanelProps } from './WorkspaceSettingsPanel';
-export { TeamSettingsPanel, type TeamSettingsPanelProps } from './TeamSettingsPanel';
-export { BillingSettingsPanel, type BillingSettingsPanelProps } from './BillingSettingsPanel';
 export { defaultSettings, type Settings } from './types';

package/src/landing/blogData.ts

@@ -269,7 +269,7 @@ The agent will read the setup guide and start a relay session, ready to coordina
 Use our SDK to enable agent-to-agent communication in your app:
 
 \`\`\`bash
-# Install agent relay and start the daemon
+# Install agent relay and start the broker
 npm install -g agent-relay
 agent-relay up
 

package/src/lib/agent-merge.test.ts

@@ -19,7 +19,7 @@ describe('mergeAgentsForDashboard', () => {
       { name: 'Lead', status: 'online' },
     ];
     const localAgents: Agent[] = [
-      { name: 'Lead', status: 'online', isLocal: true, daemonName: 'local-daemon' },
+      { name: 'Lead', status: 'online', isLocal: true, brokerName: 'local-broker' },
     ];
 
     const merged = mergeAgentsForDashboard({ agents, localAgents });
@@ -31,7 +31,7 @@ describe('mergeAgentsForDashboard', () => {
 
   it('preserves local agents when no cloud agent exists', () => {
     const localAgents: Agent[] = [
-      { name: 'Worker', status: 'online', isLocal: true, daemonName: 'local-daemon' },
+      { name: 'Worker', status: 'online', isLocal: true, brokerName: 'local-broker' },
     ];
 
     const merged = mergeAgentsForDashboard({ localAgents });

package/src/lib/api.ts

@@ -43,13 +43,13 @@ const API_BASE = getApiBaseUrl();
 // Storage key for workspace ID persistence
 const WORKSPACE_ID_KEY = 'agentrelay_workspace_id';
 
-// Workspace ID for cloud mode proxying
+// Workspace ID persistence for workspace-scoped APIs
 let activeWorkspaceId: string | null = null;
 
 // CSRF token storage key
 const CSRF_TOKEN_KEY = 'agentrelay_csrf_token';
 
-// CSRF token for cloud mode requests - persisted in sessionStorage
+// CSRF token for requests - persisted in sessionStorage
 let csrfToken: string | null = null;
 
 // Initialize from sessionStorage if available
@@ -132,42 +132,12 @@ export function initializeWorkspaceId(): string | null {
 }
 
 /**
- * Cloud-native API paths that should NOT be proxied through workspace.
- * These are routes handled by the cloud server itself, not workspace daemons.
- */
-const CLOUD_NATIVE_PATHS = [
-  '/api/daemons/',      // Linked daemons API
-  '/api/workspaces/',   // Workspace management
-  '/api/providers/',    // OAuth providers
-  '/api/auth/',         // Authentication
-  '/api/billing/',      // Billing
-  '/api/usage/',        // Usage metrics
-  '/api/admin/',        // Admin endpoints
-  '/api/onboarding/',   // Onboarding
-  '/api/repos/',        // Repository management
-  '/api/project-groups/', // Coordinators
-  '/api/github-app/',   // GitHub App
-  '/api/channels',      // Channel proxy handled by dashboard server
-  '/api/bridge',        // Bridge data (multi-repo view)
-];
-
-/**
- * Get the API URL, accounting for cloud mode proxying
+ * Get the API URL using the configured API base.
  * @param path - API path like '/api/spawn' or '/api/send'
  */
 export function getApiUrl(path: string): string {
-  if (activeWorkspaceId) {
-    // Check if this is a cloud-native path that shouldn't be proxied
-    const isCloudNative = CLOUD_NATIVE_PATHS.some(prefix => path.startsWith(prefix));
-    if (isCloudNative) {
-      return `${API_BASE}${path}`;
-    }
-    // In cloud mode, proxy through the cloud server
-    // Strip /api/ prefix since the proxy endpoint adds it back
-    const proxyPath = path.startsWith('/api/') ? path.substring(5) : path.replace(/^\//, '');
-    return `/api/workspaces/${activeWorkspaceId}/proxy/${proxyPath}`;
-  }
-  return `${API_BASE}${path}`;
+  const normalizedPath = path.startsWith('/') ? path : `/${path}`;
+  return `${API_BASE}${normalizedPath}`;
 }
 
 /**
@@ -408,17 +378,17 @@ export const api = {
   /**
    * Send a message via the relay
    */
-  async sendMessage(request: SendMessageRequest): Promise<ApiResponse<void>> {
+  async sendMessage(request: SendMessageRequest): Promise<ApiResponse<{ messageId?: string }>> {
     try {
       const response = await apiFetch(getApiUrl('/api/send'), {
         method: 'POST',
         body: JSON.stringify(request),
       });
 
-      const result = await response.json() as { success?: boolean; error?: string };
+      const result = await response.json() as { success?: boolean; error?: string; messageId?: string };
 
       if (response.ok && result.success) {
-        return { success: true };
+        return { success: true, data: { messageId: result.messageId } };
       }
 
       return { success: false, error: result.error || 'Failed to send message' };

package/src/lib/identity.test.ts

@@ -0,0 +1,139 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { isDashboardVariant, getProjectIdentity, normalizeDashboardName } from './identity';
+
+function setRelayUsername(value?: string): void {
+  const storage = (globalThis as { localStorage?: Storage }).localStorage;
+  if (!storage) return;
+  if (value) {
+    storage.setItem('relay_username', value);
+  } else {
+    storage.removeItem('relay_username');
+  }
+}
+
+function installMockLocalStorage(): void {
+  if ((globalThis as { localStorage?: Storage }).localStorage) return;
+
+  const store = new Map<string, string>();
+  const mockStorage = {
+    getItem: (key: string) => store.get(key) ?? null,
+    setItem: (key: string, value: string) => { store.set(key, value); },
+    removeItem: (key: string) => { store.delete(key); },
+    clear: () => { store.clear(); },
+    key: (index: number) => Array.from(store.keys())[index] ?? null,
+    get length() { return store.size; },
+  } satisfies Storage;
+
+  vi.stubGlobal('localStorage', mockStorage);
+}
+
+describe('isDashboardVariant', () => {
+  it('detects "Dashboard"', () => {
+    expect(isDashboardVariant('Dashboard')).toBe(true);
+  });
+
+  it('detects "Dashboard-<hex>"', () => {
+    expect(isDashboardVariant('Dashboard-5b8c70e5')).toBe(true);
+  });
+
+  it('detects "dashboard-reader"', () => {
+    expect(isDashboardVariant('dashboard-reader')).toBe(true);
+  });
+
+  it('detects "human:dashboard"', () => {
+    expect(isDashboardVariant('human:dashboard')).toBe(true);
+  });
+
+  it('is case-insensitive', () => {
+    expect(isDashboardVariant('DASHBOARD')).toBe(true);
+    expect(isDashboardVariant('dashboard')).toBe(true);
+  });
+
+  it('returns false for normal agent names', () => {
+    expect(isDashboardVariant('Natty')).toBe(false);
+    expect(isDashboardVariant('worker-1')).toBe(false);
+    expect(isDashboardVariant('test-broker-new')).toBe(false);
+  });
+
+  it('returns false for empty/whitespace strings', () => {
+    expect(isDashboardVariant('')).toBe(false);
+    expect(isDashboardVariant('   ')).toBe(false);
+  });
+});
+
+describe('getProjectIdentity', () => {
+  beforeEach(() => {
+    installMockLocalStorage();
+    setRelayUsername(undefined);
+  });
+
+  afterEach(() => {
+    setRelayUsername(undefined);
+  });
+
+  it('returns explicit identity when provided', () => {
+    expect(getProjectIdentity('my-project')).toBe('my-project');
+  });
+
+  it('returns localStorage value when no explicit identity', () => {
+    setRelayUsername('stored-user');
+    expect(getProjectIdentity()).toBe('stored-user');
+  });
+
+  it('returns "Dashboard" as final fallback', () => {
+    expect(getProjectIdentity()).toBe('Dashboard');
+  });
+
+  it('explicit identity takes priority over localStorage', () => {
+    setRelayUsername('stored-user');
+    expect(getProjectIdentity('explicit-user')).toBe('explicit-user');
+  });
+
+  it('trims whitespace from explicit identity', () => {
+    expect(getProjectIdentity('  spaced  ')).toBe('spaced');
+  });
+
+  it('skips blank explicit identity and falls back', () => {
+    setRelayUsername('stored-user');
+    expect(getProjectIdentity('   ')).toBe('stored-user');
+  });
+});
+
+describe('normalizeDashboardName', () => {
+  beforeEach(() => {
+    installMockLocalStorage();
+    setRelayUsername(undefined);
+  });
+
+  afterEach(() => {
+    setRelayUsername(undefined);
+  });
+
+  it('maps Dashboard variants to the project identity', () => {
+    setRelayUsername('test-broker-new');
+    expect(normalizeDashboardName('Dashboard-5b8c70e5')).toBe('test-broker-new');
+    expect(normalizeDashboardName('Dashboard')).toBe('test-broker-new');
+    expect(normalizeDashboardName('dashboard-reader')).toBe('test-broker-new');
+  });
+
+  it('passes non-Dashboard names through unchanged', () => {
+    expect(normalizeDashboardName('Natty')).toBe('Natty');
+    expect(normalizeDashboardName('worker-1')).toBe('worker-1');
+  });
+
+  it('falls back to "Dashboard" when no identity is stored', () => {
+    expect(normalizeDashboardName('Dashboard-5b8c70e5')).toBe('Dashboard');
+  });
+
+  it('uses explicit project identity when provided', () => {
+    expect(normalizeDashboardName('Dashboard-5b8c70e5', 'my-project')).toBe('my-project');
+  });
+
+  it('returns original value for empty input', () => {
+    expect(normalizeDashboardName('')).toBe('');
+  });
+
+  it('trims non-Dashboard names', () => {
+    expect(normalizeDashboardName('  Natty  ')).toBe('Natty');
+  });
+});

package/src/lib/identity.ts

@@ -0,0 +1,48 @@
+/**
+ * Frontend identity resolution module.
+ * Single source of truth for Dashboard identity normalization on the client.
+ */
+
+// Dashboard variant pattern (Dashboard, Dashboard-<hex>, dashboard-reader)
+const DASHBOARD_VARIANT_PATTERN = /^dashboard(-[0-9a-f]{6,}|-reader)?$/i;
+
+export function isDashboardVariant(name: string): boolean {
+  if (!name?.trim()) return false;
+  const lower = name.trim().toLowerCase();
+  return lower === 'dashboard' || lower === 'human:dashboard' || DASHBOARD_VARIANT_PATTERN.test(name.trim());
+}
+
+/**
+ * Get the project display identity from available sources.
+ * Priority: explicit param > localStorage > "Dashboard"
+ */
+export function getProjectIdentity(explicitIdentity?: string | null): string {
+  if (explicitIdentity?.trim()) return explicitIdentity.trim();
+  // Try localStorage as fallback (for when context isn't available).
+  // Use globalThis to support both browser (window.localStorage) and test environments
+  // where vitest stubs localStorage on globalThis without defining window.
+  const storage = (
+    typeof window !== 'undefined'
+      ? window.localStorage
+      : (globalThis as { localStorage?: Storage }).localStorage
+  );
+  if (storage) {
+    try {
+      const stored = storage.getItem('relay_username');
+      if (stored?.trim()) return stored.trim();
+    } catch { /* SSR or blocked */ }
+  }
+  return 'Dashboard';
+}
+
+/**
+ * Normalize a name: map Dashboard variants to the project identity.
+ * Non-Dashboard names pass through unchanged.
+ */
+export function normalizeDashboardName(name: string, projectIdentity?: string | null): string {
+  if (!name?.trim()) return name;
+  if (isDashboardVariant(name.trim())) {
+    return getProjectIdentity(projectIdentity);
+  }
+  return name.trim();
+}