@xenosystem/agent-interface-ui 0.1.25 → 0.1.27

package/dist/stores/entitySettingsStore.js

@@ -1,8 +1,8 @@
 import { getAgentPlatformBridge } from '../platformBridge.js';
+import { isAgentUsageResult } from '@xenosystem/agent-interface-contract';
 import { create } from 'zustand';
-import { useWorkspaceStore } from './workspaceStore.js';
-import { useAgentChatStore } from './agentChatStore.js';
-import { useAuthStore } from './authStore.js';
+import { useWorkspaceStore, toolsForAgentCapabilities, requestWorkspaceLifecycle, requireWorkspacePersistence } from './workspaceStore.js';
+import { useAgentChatStore, loadLocalAgentConversations } from './agentChatStore.js';
 export const SETTINGS_SECTIONS = [
     { id: 'general', label: 'General', icon: 'settings', availableFor: ['workspace', 'team', 'agent'] },
     { id: 'directoryAccess', label: 'Directory Access', icon: 'folder', availableFor: ['workspace', 'team', 'agent'] },
@@ -11,274 +11,263 @@ export const SETTINGS_SECTIONS = [
     { id: 'resourceLimits', label: 'Resource Limits', icon: 'gauge', availableFor: ['workspace', 'team', 'agent'] },
     { id: 'usage', label: 'Usage & Analytics', icon: 'barChart', availableFor: ['workspace', 'team', 'agent'] },
     { id: 'integrations', label: 'Integrations', icon: 'plug', availableFor: ['workspace', 'team'] },
-    { id: 'environment', label: 'Environment & Secrets', icon: 'key', availableFor: ['workspace', 'team'] },
+    { id: 'environment', label: 'Environment & Secrets', icon: 'key', availableFor: ['workspace', 'team', 'agent'] },
     { id: 'notifications', label: 'Notifications', icon: 'bell', availableFor: ['workspace', 'team', 'agent'] },
     { id: 'security', label: 'Security & Compliance', icon: 'shield', availableFor: ['workspace', 'team'] },
-    { id: 'exportBackup', label: 'Export & Backup', icon: 'download', availableFor: ['workspace', 'team'] },
+    { id: 'exportBackup', label: 'Export & Backup', icon: 'download', availableFor: ['workspace', 'team', 'agent'] },
     { id: 'dangerZone', label: 'Danger Zone', icon: 'alertTriangle', availableFor: ['workspace', 'team', 'agent'] },
 ];
 export function getSectionsForEntity(entityType) {
     return SETTINGS_SECTIONS.filter(s => s.availableFor.includes(entityType));
 }
 // =============================================================================
-// MOCK DATA GENERATOR
+// INITIAL UNOBSERVED STATE
 // =============================================================================
 function generateId() {
     return `${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
 }
-function generateMockSettings(entityId, entityType, entityName, extra) {
-    const now = new Date().toISOString();
-    const thirtyDaysAgo = new Date(Date.now() - 30 * 86400000).toISOString();
-    const owner = {
-        id: 'user_owner_1',
-        name: 'You',
-        email: 'you@example.com',
-        role: 'owner',
-        joinedAt: thirtyDaysAgo,
-    };
-    const members = [
-        owner,
-        { id: 'user_2', name: 'Alice Chen', email: 'alice@example.com', role: 'admin', joinedAt: thirtyDaysAgo },
-        { id: 'user_3', name: 'Bob Smith', email: 'bob@example.com', role: 'editor', joinedAt: now },
-    ];
-    const dailyUsage = Array.from({ length: 7 }, (_, i) => ({
-        label: ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun'][i],
-        value: Math.floor(Math.random() * 50000) + 5000,
-    }));
-    const weeklyUsage = Array.from({ length: 4 }, (_, i) => ({
-        label: `Week ${i + 1}`,
-        value: Math.floor(Math.random() * 200000) + 50000,
-    }));
-    const monthlyUsage = Array.from({ length: 6 }, (_, i) => ({
-        label: ['Aug', 'Sep', 'Oct', 'Nov', 'Dec', 'Jan'][i],
-        value: Math.floor(Math.random() * 800000) + 100000,
-    }));
-    const workspaceQuotas = [
-        { label: 'Teams', current: 3, limit: 10, unit: 'teams' },
-        { label: 'Tokens / month', current: 425000, limit: 1000000, unit: 'tokens' },
-        { label: 'Storage', current: 2.4, limit: 10, unit: 'GB' },
-    ];
-    const teamQuotas = [
-        { label: 'Agents', current: 5, limit: 20, unit: 'agents' },
-        { label: 'Tokens / month', current: 180000, limit: 500000, unit: 'tokens' },
-    ];
-    const agentQuotas = [
-        { label: 'Tokens / month', current: 42000, limit: 100000, unit: 'tokens' },
-    ];
-    const quotas = entityType === 'workspace' ? workspaceQuotas : entityType === 'team' ? teamQuotas : agentQuotas;
+function createInitialSettings(entityId, entityType, entityName, extra) {
+    // Empty means unobserved, not a synthetic successful response. Load statuses
+    // distinguish unavailable services from successfully observed empty collections.
+    const owner = null;
     return {
-        entityId,
-        entityType,
-        entityName,
-        workspaceId: extra?.workspaceId,
-        workspaceName: extra?.workspaceName,
-        teamId: extra?.teamId,
-        teamName: extra?.teamName,
+        entityId, entityType, entityName,
+        workspaceId: extra?.workspaceId, workspaceName: extra?.workspaceName,
+        teamId: extra?.teamId, teamName: extra?.teamName,
         general: {
-            name: entityName,
-            description: `A ${entityType} for managing AI operations.`,
-            icon: entityType === 'workspace' ? 'building' : entityType === 'team' ? 'users' : 'bot',
-            slug: entityName.toLowerCase().replace(/\s+/g, '-'),
-            createdAt: thirtyDaysAgo,
-            updatedAt: now,
-        },
-        defaultAgentConfig: entityType !== 'agent' ? {
-            defaultModel: 'claude-sonnet-4-6',
-            systemInstructions: 'You are a helpful AI assistant.',
-            enabledTools: ['web-search', 'code-execution', 'file-read'],
-            availableTools: ['web-search', 'code-execution', 'file-read', 'file-write', 'image-generation', 'data-analysis'],
-        } : undefined,
-        access: {
-            owner,
-            members: entityType === 'agent' ? [owner] : members,
-            pendingInvites: entityType === 'agent' ? [] : [
-                { id: 'inv_1', email: 'carol@example.com', role: 'viewer', sentAt: now, expiresAt: new Date(Date.now() + 7 * 86400000).toISOString() },
-            ],
-            publicAccess: false,
-            allowGuestViewing: false,
-        },
-        resourceLimits: {
-            quotas,
-            rateLimitRpm: entityType === 'workspace' ? 1000 : entityType === 'team' ? 500 : 100,
-            rateLimitTpd: entityType === 'workspace' ? 1000000 : entityType === 'team' ? 500000 : 100000,
-        },
-        usage: {
-            totalTokens: 425000,
-            totalCost: 12.50,
-            totalRequests: 1842,
-            dailyUsage,
-            weeklyUsage,
-            monthlyUsage,
-            costByModel: [
-                { model: 'Opus 4.5', cost: 8.20, tokens: 280000 },
-                { model: 'GPT 5.3 Codex', cost: 3.10, tokens: 105000 },
-                { model: 'Flash 3.0', cost: 1.20, tokens: 40000 },
-            ],
-            topAgents: [
-                { name: 'Code Reviewer', tokens: 120000, cost: 3.60 },
-                { name: 'Research Bot', tokens: 95000, cost: 2.85 },
-                { name: 'Doc Writer', tokens: 72000, cost: 2.16 },
-            ],
+            name: entityName, description: '', icon: entityType === 'workspace' ? 'building' : entityType === 'team' ? 'users' : 'bot',
+            slug: entityName.toLowerCase().replace(/\s+/g, '-'), createdAt: '', updatedAt: '',
         },
+        defaultAgentConfig: entityType !== 'agent'
+            ? { defaultModel: '', systemInstructions: '', enabledTools: [], availableTools: [] }
+            : undefined,
+        access: { owner, members: [], pendingInvites: [], publicAccess: false, allowGuestViewing: false },
+        resourceLimits: { quotas: [], rateLimitRpm: 0, rateLimitTpd: 0 },
+        usage: { totalTokens: 0, totalCost: null, totalRequests: 0, dailyUsage: [], weeklyUsage: [], monthlyUsage: [], costByModel: [], topAgents: [] },
         integrations: {
             integrations: [
-                { id: 'int_1', type: 'github', name: 'GitHub', enabled: true, connectedAt: thirtyDaysAgo, status: 'connected' },
-                { id: 'int_2', type: 'slack', name: 'Slack', enabled: false, connectedAt: '', status: 'disconnected' },
-                { id: 'int_3', type: 'discord', name: 'Discord', enabled: false, connectedAt: '', status: 'disconnected' },
-                { id: 'int_4', type: 'webhook', name: 'Custom Webhook', enabled: true, connectedAt: thirtyDaysAgo, status: 'connected', config: { url: 'https://api.example.com/webhook' } },
-            ],
-            apiKeys: [
-                { id: 'key_1', name: 'Production Key', prefix: 'xk_prod_...a3f2', createdAt: thirtyDaysAgo, lastUsed: now },
-                { id: 'key_2', name: 'Development Key', prefix: 'xk_dev_...b1c4', createdAt: now, lastUsed: now },
-            ],
-            webhookEndpoints: [
-                { id: 'wh_1', url: 'https://api.example.com/webhook', events: ['agent.started', 'agent.completed'], enabled: true, secret: 'whsec_...x9y2', createdAt: thirtyDaysAgo },
-            ],
-        },
-        environment: {
-            variables: [
-                { id: 'env_1', key: 'API_BASE_URL', value: 'https://api.example.com', isSecret: false, updatedAt: now },
-                { id: 'env_2', key: 'DATABASE_URL', value: '••••••••••••', isSecret: true, updatedAt: thirtyDaysAgo },
-                { id: 'env_3', key: 'OPENAI_API_KEY', value: '••••••••••••', isSecret: true, updatedAt: thirtyDaysAgo },
-            ],
-        },
-        notifications: {
-            emailEnabled: true,
-            slackEnabled: false,
-            discordEnabled: false,
-            webhookEnabled: true,
-            rules: [
-                { id: 'rule_1', event: 'Agent Error', channel: 'email', enabled: true, description: 'Notify when an agent encounters an error' },
-                { id: 'rule_2', event: 'Task Completed', channel: 'webhook', enabled: true, description: 'Webhook on task completion' },
-                { id: 'rule_3', event: 'Quota Warning', channel: 'email', enabled: true, description: 'Alert when approaching usage limits' },
-            ],
-            digestFrequency: 'daily',
-        },
-        security: {
-            auditLog: [
-                { id: 'log_1', action: 'member.added', actor: 'You', target: 'Alice Chen', timestamp: now, details: 'Added as admin' },
-                { id: 'log_2', action: 'settings.updated', actor: 'You', target: 'General Settings', timestamp: thirtyDaysAgo, details: 'Updated workspace name' },
-                { id: 'log_3', action: 'agent.created', actor: 'Alice Chen', target: 'Code Reviewer', timestamp: thirtyDaysAgo, details: 'Created new agent' },
-                { id: 'log_4', action: 'apikey.created', actor: 'You', target: 'Production Key', timestamp: thirtyDaysAgo, details: 'Created API key' },
-                { id: 'log_5', action: 'member.role_changed', actor: 'You', target: 'Bob Smith', timestamp: now, details: 'Changed role to editor' },
-            ],
-            ipAllowlist: [],
-            require2FA: false,
-            requireApiKeyAuth: true,
-            sessionTimeout: 30,
-        },
-        exportBackup: {
-            autoBackupEnabled: true,
-            backupFrequency: 'weekly',
-            retentionDays: 30,
-            availableBackups: [
-                { id: 'bk_1', name: 'Auto Backup', size: '2.4 MB', createdAt: now, type: 'auto' },
-                { id: 'bk_2', name: 'Pre-migration Backup', size: '1.8 MB', createdAt: thirtyDaysAgo, type: 'manual' },
-            ],
-            availableExports: [
-                { format: 'json', label: 'JSON Export' },
-                { format: 'csv', label: 'CSV Export' },
-                { format: 'yaml', label: 'YAML Export' },
+                { id: 'github', type: 'github', name: 'GitHub', enabled: false, connectedAt: '', status: 'disconnected' },
+                { id: 'slack', type: 'slack', name: 'Slack', enabled: false, connectedAt: '', status: 'disconnected' },
+                { id: 'discord', type: 'discord', name: 'Discord', enabled: false, connectedAt: '', status: 'disconnected' },
             ],
+            apiKeys: [], webhookEndpoints: [],
         },
-        dangerZone: {
-            canArchive: true,
-            canTransferOwnership: true,
-            canDelete: true,
+        environment: { variables: [] },
+        notifications: { emailEnabled: false, slackEnabled: false, discordEnabled: false, webhookEnabled: false, rules: [], digestFrequency: 'daily' },
+        security: { auditLog: [], ipAllowlist: [], require2FA: false, requireApiKeyAuth: false, sessionTimeout: 0 },
+        exportBackup: { autoBackupEnabled: false, backupFrequency: 'weekly', retentionDays: 30, availableBackups: [], availableExports: [{ format: 'json', label: 'JSON Export' }, { format: 'csv', label: 'CSV Export' }] },
+        dangerZone: { canArchive: true, canTransferOwnership: false, canDelete: true },
+    };
+}
+let selectedHierarchyBaseline;
+const profileDrafts = new WeakMap();
+function currentProfileDrafts() {
+    const storage = getAgentPlatformBridge()?.workspaceStorage;
+    if (!storage)
+        return new Map();
+    let drafts = profileDrafts.get(storage);
+    if (!drafts) {
+        drafts = new Map();
+        profileDrafts.set(storage, drafts);
+    }
+    return drafts;
+}
+function profileIdentityExists(identity, workspaces) {
+    const [workspaceId, createdAt, teamId, agentId] = JSON.parse(identity);
+    const matches = workspaces.filter(workspace => workspace.id === workspaceId && workspace.createdAt === createdAt);
+    if (matches.length !== 1)
+        return false;
+    if (teamId === null)
+        return true;
+    const teams = matches[0].teams.filter(team => team.id === teamId);
+    return teams.length === 1 && (agentId === null || teams[0].agents.filter(agent => agent.id === agentId).length === 1);
+}
+export function validateProfileDraft(profile) {
+    if (!profile.name.trim())
+        return 'Name is required. Enter a name or discard profile changes.';
+    if (profile.name.length > 200)
+        return 'Name must be at most 200 characters.';
+    if (/[\u0000-\u001f\u007f-\u009f]/.test(profile.name))
+        return 'Name cannot contain control characters.';
+    if (profile.description.length > 4000)
+        return 'Description must be at most 4000 characters.';
+    if (/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f-\u009f]/.test(profile.description))
+        return 'Description contains unsupported control characters.';
+    return undefined;
+}
+if (typeof window !== 'undefined')
+    window.addEventListener('beforeunload', event => {
+        if (!currentProfileDrafts().size)
+            return;
+        event.preventDefault();
+        event.returnValue = '';
+    });
+/** One projection shared by initial load and acknowledged remote reconciliation. */
+function projectHierarchySettings(settings, workspaces) {
+    const matches = workspaces.filter(w => w.id === (settings.entityType === 'workspace' ? settings.entityId : settings.workspaceId));
+    if (matches.length !== 1)
+        return undefined;
+    const workspace = matches[0];
+    const teams = settings.entityType === 'workspace' ? [] : workspace.teams.filter(t => t.id === (settings.entityType === 'team' ? settings.entityId : settings.teamId));
+    if (settings.entityType !== 'workspace' && teams.length !== 1)
+        return undefined;
+    const team = teams[0];
+    const agents = settings.entityType === 'agent' ? team.agents.filter(a => a.id === settings.entityId) : [];
+    if (settings.entityType === 'agent' && agents.length !== 1)
+        return undefined;
+    const agent = agents[0];
+    const entity = agent ?? team ?? workspace;
+    const defaults = settings.entityType === 'workspace' ? workspace.agentDefaults
+        : settings.entityType === 'team' ? { ...workspace.agentDefaults, ...team?.agentDefaults }
+            : { model: agent?.model, systemPrompt: agent?.systemPrompt, tools: agent?.tools ?? toolsForAgentCapabilities(agent?.capabilities) };
+    const createdAt = Number.isFinite(workspace.createdAt) ? new Date(workspace.createdAt).toISOString() : '';
+    return {
+        // Team/Agent IDs have no generation field in the current canonical schema.
+        // Observed disappearance invalidates selection; workspace recreation is exact.
+        identity: JSON.stringify([workspace.id, workspace.createdAt, team?.id ?? null, agent?.id ?? null]),
+        entityName: entity.name, workspaceName: workspace.name, ...(team ? { teamName: team.name } : {}),
+        general: {
+            name: entity.name, description: entity.description ?? '',
+            slug: entity.name.toLowerCase().replace(/\s+/g, '-').replace(/[^a-z0-9-]/g, ''),
+            icon: settings.entityType === 'workspace' ? 'building' : settings.entityType === 'team' ? 'users' : 'bot',
+            createdAt: settings.entityType === 'workspace' ? createdAt : settings.general.createdAt,
+            updatedAt: settings.entityType === 'workspace' ? (workspace.updatedAt ? new Date(workspace.updatedAt).toISOString() : createdAt) : settings.general.updatedAt,
         },
+        ...(settings.defaultAgentConfig ? { defaultAgentConfig: {
+                defaultModel: defaults?.model ?? '', systemInstructions: defaults?.systemPrompt ?? '',
+                enabledTools: [...(defaults?.tools ?? toolsForAgentCapabilities())],
+                availableTools: settings.defaultAgentConfig.availableTools,
+            } } : {}),
     };
 }
+function mergeAcknowledgedFields(local, previous, incoming) {
+    const merged = { ...local };
+    for (const key of Object.keys(incoming)) {
+        if (JSON.stringify(local[key]) === JSON.stringify(previous[key]))
+            merged[key] = incoming[key];
+    }
+    return merged;
+}
 function normalizeBackupFrequency(value, fallback) {
     return value === 'daily' || value === 'weekly' || value === 'monthly' ? value : fallback;
 }
-// Async load real data for IPC-backed sections (export, usage, security)
-async function loadAsyncSectionData(entityId, entityType) {
+function backupScope(settings) {
+    const scope = {
+        workspaceId: settings.entityType === 'workspace' ? settings.entityId : settings.workspaceId,
+        teamId: settings.entityType === 'team' ? settings.entityId : settings.teamId,
+        agentId: settings.entityType === 'agent' ? settings.entityId : undefined,
+    };
+    return { ...scope, caller: { ...scope } };
+}
+function requireSuccess(value, operation) {
+    if (!value || typeof value !== 'object' || value.success !== true) {
+        const error = value?.error;
+        throw new Error(typeof error === 'string' ? error : `${operation} was not confirmed by the host.`);
+    }
+}
+function settingsError(error) {
+    return error instanceof Error ? error.message : 'The host operation failed.';
+}
+// Each load has a generation, not just an entity id: A -> B -> A must not accept
+// a response from the first A. Independent services load concurrently.
+async function loadAsyncSectionData(settings, generation) {
     const store = useEntitySettingsStore;
-    // Load real backup data
-    try {
-        const [backupList, backupSettings] = await Promise.all([
-            getAgentPlatformBridge()?.exportBackup?.listBackups?.(),
-            getAgentPlatformBridge()?.exportBackup?.getSettings?.(),
-        ]);
-        const current = store.getState().settings;
-        if (current?.entityId === entityId) {
-            const normalizedBackupFrequency = normalizeBackupFrequency(backupSettings?.settings?.frequency, current.exportBackup.backupFrequency);
-            store.setState({
-                settings: {
-                    ...current,
-                    exportBackup: {
-                        ...current.exportBackup,
-                        autoBackupEnabled: backupSettings?.settings?.autoBackupEnabled ?? current.exportBackup.autoBackupEnabled,
-                        backupFrequency: normalizedBackupFrequency,
-                        retentionDays: backupSettings?.settings?.retentionDays ?? current.exportBackup.retentionDays,
-                        availableBackups: (backupList?.backups || []).map((b) => ({
-                            id: b.id,
-                            name: b.name,
-                            size: formatBytes(b.size),
-                            createdAt: b.createdAt,
-                            type: 'manual',
-                        })),
-                    },
-                },
-            });
+    const load = async (section, read) => {
+        try {
+            const patch = await read();
+            const state = store.getState();
+            if (state.loadGeneration !== generation || !state.settings)
+                return;
+            store.setState({ settings: { ...state.settings, ...patch } });
         }
-    }
-    catch { /* silent */ }
-    // Load real usage data
+        catch (error) {
+            if (store.getState().loadGeneration === generation) {
+                store.setState(state => ({ sectionErrors: { ...state.sectionErrors, [section]: settingsError(error) } }));
+            }
+        }
+        finally {
+            if (store.getState().loadGeneration === generation) {
+                store.setState(state => ({ sectionLoading: { ...state.sectionLoading, [section]: false } }));
+            }
+        }
+    };
+    await Promise.all([
+        load('environment', async () => {
+            const api = getAgentPlatformBridge().workspace.environment;
+            if (!api)
+                throw new Error('Protected environment service is unavailable on this host.');
+            const result = await api({ scope: environmentScope(settings), action: 'list' });
+            requireSuccess(result, 'Environment load');
+            return { environment: environmentMetadata(result) };
+        }),
+        load('exportBackup', async () => {
+            const api = getAgentPlatformBridge().exportBackup;
+            if (!api?.listBackups || !api.getSettings)
+                throw new Error('Backup service is not available on this host.');
+            const [list, policy] = await Promise.all([api.listBackups(backupScope(settings)), api.getSettings(backupScope(settings))]);
+            requireSuccess(list, 'Backup listing');
+            requireSuccess(policy, 'Backup policy');
+            if (!Array.isArray(list.backups) || !policy.settings)
+                throw new Error('The host returned an invalid backup response.');
+            return { exportBackup: {
+                    ...settings.exportBackup,
+                    autoBackupEnabled: policy.settings.autoBackupEnabled,
+                    backupFrequency: normalizeBackupFrequency(policy.settings.frequency, settings.exportBackup.backupFrequency),
+                    retentionDays: policy.settings.retentionDays,
+                    lastError: policy.settings.lastError,
+                    availableBackups: list.backups.map(b => ({
+                        id: b.id, name: b.name, size: formatBytes(b.size), createdAt: b.createdAt, type: 'manual',
+                    })),
+                } };
+        }),
+        load('usage', async () => {
+            const api = getAgentPlatformBridge().usage;
+            if (!api?.snapshot)
+                throw new Error('Scoped usage service is not available on this host.');
+            const result = await api.snapshot({ entityType: settings.entityType, entityId: settings.entityId });
+            if (!isAgentUsageResult(result))
+                throw new Error('The host returned an invalid usage response.');
+            if (!result.success)
+                throw new Error(result.error);
+            const summary = result.snapshot;
+            if (!Number.isSafeInteger(summary.totalTokens) || summary.totalTokens < 0 || !Array.isArray(summary.costByModel) || !Array.isArray(summary.topAgents)) {
+                throw new Error('The host returned an invalid usage response.');
+            }
+            return { usage: {
+                    totalTokens: summary.totalTokens, totalCost: summary.totalCost, totalRequests: summary.totalRequests,
+                    unmeasuredRequests: summary.unmeasuredRequests, observedAt: summary.observedAt,
+                    dailyUsage: summary.dailyUsage, weeklyUsage: summary.weeklyUsage, monthlyUsage: summary.monthlyUsage,
+                    costByModel: summary.costByModel, topAgents: summary.topAgents,
+                } };
+        }),
+    ]);
+}
+async function runBackupOperation(operation) {
+    const store = useEntitySettingsStore;
+    const state = store.getState();
+    if (!state.settings || state.backupBusy || state.sectionLoading.exportBackup)
+        return;
+    const { settings, loadGeneration } = state;
+    store.setState({ backupBusy: true, sectionErrors: { ...state.sectionErrors, exportBackup: undefined } });
     try {
-        const [summary, byModel, topAgents] = await Promise.all([
-            getAgentPlatformBridge()?.usage?.summary?.(entityType, entityId, 'daily'),
-            getAgentPlatformBridge()?.usage?.byModel?.(),
-            getAgentPlatformBridge()?.usage?.topAgents?.(),
-        ]);
-        const current = store.getState().settings;
-        if (current?.entityId === entityId) {
-            const usageSummary = (summary || {});
-            const usageByModel = (byModel || {});
-            const usageTopAgents = (topAgents || {});
-            store.setState({
-                settings: {
-                    ...current,
-                    usage: {
-                        totalTokens: usageSummary.totalTokens ?? 0,
-                        totalCost: usageSummary.totalCost ?? 0,
-                        totalRequests: usageSummary.totalRequests ?? 0,
-                        dailyUsage: usageSummary.dataPoints || [],
-                        weeklyUsage: [],
-                        monthlyUsage: [],
-                        costByModel: usageByModel.costByModel || [],
-                        topAgents: usageTopAgents.topAgents || [],
-                    },
-                },
-            });
+        const api = getAgentPlatformBridge().exportBackup;
+        if (!api)
+            throw new Error('Backup service is not available on this host.');
+        const patch = await operation(api, settings);
+        const current = store.getState();
+        if (current.loadGeneration === loadGeneration && current.settings && patch) {
+            store.setState({ settings: { ...current.settings, exportBackup: { ...current.settings.exportBackup, ...patch } } });
         }
     }
-    catch { /* silent */ }
-    // Load real audit log
-    try {
-        const result = await getAgentPlatformBridge()?.audit?.list?.(20);
-        const current = store.getState().settings;
-        if (current?.entityId === entityId) {
-            const auditEntries = (result || {}).entries || [];
-            store.setState({
-                settings: {
-                    ...current,
-                    security: {
-                        ...current.security,
-                        auditLog: auditEntries.map((e, i) => ({
-                            id: `audit_${i}`,
-                            action: e.action,
-                            actor: e.user || 'You',
-                            target: e.entity || '',
-                            timestamp: e.timestamp,
-                            details: e.details || '',
-                        })),
-                    },
-                },
-            });
+    catch (error) {
+        if (store.getState().loadGeneration === loadGeneration) {
+            store.setState(current => ({ sectionErrors: { ...current.sectionErrors, exportBackup: settingsError(error) } }));
         }
     }
-    catch { /* silent */ }
+    finally {
+        if (store.getState().loadGeneration === loadGeneration)
+            store.setState({ backupBusy: false });
+    }
 }
 function formatBytes(bytes) {
     if (bytes < 1024)
@@ -303,39 +292,69 @@ function syncNotificationsToWorkspaceStore(settings, notif) {
     });
 }
 // Sync env vars from settings back to workspace store
-function syncEnvVarsToWorkspaceStore(settings, vars) {
-    const envVars = vars.map(v => ({ key: v.key, value: v.value, isSecret: v.isSecret }));
-    const ws = useWorkspaceStore.getState();
-    if (settings.entityType === 'workspace') {
-        ws.updateWorkspace(settings.entityId, { envVars });
+function environmentScope(settings) {
+    const value = backupScope(settings);
+    return { workspaceId: String(value.workspaceId || ''), ...(value.teamId ? { teamId: String(value.teamId) } : {}), ...(value.agentId ? { agentId: String(value.agentId) } : {}) };
+}
+function environmentMetadata(result) {
+    if (!Array.isArray(result.variables))
+        throw new Error('Invalid environment metadata from host');
+    return { environmentRevision: result.environmentRevision, protectedStorageAvailable: result.protectedStorageAvailable, variables: result.variables.map(variable => ({ ...variable, id: variable.key, value: '' })) };
+}
+async function changeEnvironment(input) {
+    const store = useEntitySettingsStore;
+    const initial = store.getState();
+    if (!initial.settings || initial.environmentBusy || initial.sectionLoading.environment)
+        return false;
+    const generation = initial.loadGeneration;
+    store.setState({ environmentBusy: true, sectionErrors: { ...initial.sectionErrors, environment: undefined } });
+    try {
+        const bridge = getAgentPlatformBridge();
+        const api = bridge.workspace.environment;
+        if (!api)
+            throw new Error('Protected environment service is unavailable on this host.');
+        const state = await bridge.workspaceStorage.load();
+        if (!state.success || !state.revision)
+            throw new Error('Reload workspace state before changing environment values.');
+        const result = await api({ ...input, scope: environmentScope(initial.settings), expectedRevision: state.revision, expectedEnvironmentRevision: initial.settings.environment.environmentRevision });
+        requireSuccess(result, 'Environment update');
+        if (store.getState().loadGeneration === generation)
+            store.setState(current => ({ settings: current.settings ? { ...current.settings, environment: environmentMetadata(result) } : null }));
+        return true;
     }
-    else if (settings.entityType === 'team' && settings.workspaceId) {
-        ws.updateTeam(settings.workspaceId, settings.entityId, { envVars });
+    catch (error) {
+        if (store.getState().loadGeneration === generation)
+            store.setState(current => ({ sectionErrors: { ...current.sectionErrors, environment: settingsError(error) } }));
+        return false;
+    }
+    finally {
+        if (store.getState().loadGeneration === generation)
+            store.setState({ environmentBusy: false });
     }
 }
 export const useEntitySettingsStore = create((set, get) => ({
+    environmentBusy: false,
     settings: null,
     activeSection: 'general',
     isLoading: false,
     isDirty: false,
+    profileDraftPending: false,
+    profileDraftError: undefined,
+    loadGeneration: 0,
+    sectionErrors: {},
+    sectionLoading: {},
+    backupBusy: false,
     loadSettings: (entityId, entityType, entityName, extra) => {
-        set({ isLoading: true });
-        // Start with mock structure, then overlay real data from workspace store
-        const settings = generateMockSettings(entityId, entityType, entityName, extra);
+        const generation = get().loadGeneration + 1;
+        set({ isLoading: true, loadGeneration: generation, sectionErrors: {}, backupBusy: false,
+            environmentBusy: false, backupRestoreResult: undefined,
+            sectionLoading: { exportBackup: true, usage: true, environment: true } });
+        const settings = createInitialSettings(entityId, entityType, entityName, extra);
         const wsStore = useWorkspaceStore.getState();
         // Get current user from auth store for real owner info
-        const authUser = useAuthStore.getState().user;
         if (entityType === 'workspace') {
             const ws = wsStore.workspaces.find(w => w.id === entityId);
             if (ws) {
-                // General — all real
-                const slug = ws.name.toLowerCase().replace(/\s+/g, '-').replace(/[^a-z0-9-]/g, '');
-                settings.general.name = ws.name;
-                settings.general.description = ws.description || '';
-                settings.general.slug = slug;
-                settings.general.icon = 'building';
-                settings.general.createdAt = ws.createdAt ? new Date(ws.createdAt).toISOString() : settings.general.createdAt;
-                settings.general.updatedAt = ws.updatedAt ? new Date(ws.updatedAt).toISOString() : settings.general.createdAt;
                 // Resource limits — real quotas from hierarchy
                 const teamCount = ws.teams.length;
                 const agentCount = ws.teams.reduce((sum, t) => sum + t.agents.length, 0);
@@ -351,6 +370,8 @@ export const useEntitySettingsStore = create((set, get) => ({
                     variables: (ws.envVars || []).map((v, i) => ({
                         id: `env_${i}`,
                         ...v,
+                        value: '',
+                        legacy: true,
                         updatedAt: new Date().toISOString(),
                     })),
                 };
@@ -369,11 +390,9 @@ export const useEntitySettingsStore = create((set, get) => ({
                     };
                 }
                 // Access — real current user as owner, no fake members
-                const ownerName = authUser?.display_name || authUser?.username || 'You';
-                const ownerEmail = authUser?.email || '';
                 settings.access = {
-                    owner: { id: 'self', name: ownerName, email: ownerEmail, role: 'owner', joinedAt: settings.general.createdAt },
-                    members: [{ id: 'self', name: ownerName, email: ownerEmail, role: 'owner', joinedAt: settings.general.createdAt }],
+                    owner: null,
+                    members: [],
                     pendingInvites: [],
                     publicAccess: ws.access?.publicAccess ?? false,
                     allowGuestViewing: ws.access?.allowGuestViewing ?? false,
@@ -397,10 +416,6 @@ export const useEntitySettingsStore = create((set, get) => ({
             const ws = wsStore.workspaces.find(w => w.id === extra.workspaceId);
             const team = ws?.teams.find(t => t.id === entityId);
             if (team) {
-                settings.general.name = team.name;
-                settings.general.description = team.description || '';
-                settings.general.slug = team.name.toLowerCase().replace(/\s+/g, '-').replace(/[^a-z0-9-]/g, '');
-                settings.general.icon = 'users';
                 settings.resourceLimits.quotas = [
                     { label: 'Agents', current: team.agents.length, limit: 50, unit: 'agents' },
                 ];
@@ -410,15 +425,15 @@ export const useEntitySettingsStore = create((set, get) => ({
                     variables: (team.envVars || []).map((v, i) => ({
                         id: `env_${i}`,
                         ...v,
+                        value: '',
+                        legacy: true,
                         updatedAt: new Date().toISOString(),
                     })),
                 };
                 // Real owner
-                const ownerName = authUser?.display_name || authUser?.username || 'You';
-                const ownerEmail = authUser?.email || '';
                 settings.access = {
-                    owner: { id: 'self', name: ownerName, email: ownerEmail, role: 'owner', joinedAt: settings.general.createdAt },
-                    members: [{ id: 'self', name: ownerName, email: ownerEmail, role: 'owner', joinedAt: settings.general.createdAt }],
+                    owner: null,
+                    members: [],
                     pendingInvites: [],
                     publicAccess: false,
                     allowGuestViewing: false,
@@ -430,65 +445,102 @@ export const useEntitySettingsStore = create((set, get) => ({
             const team = ws?.teams.find(t => t.id === extra.teamId);
             const agent = team?.agents.find(a => a.id === entityId);
             if (agent) {
-                settings.general.name = agent.name;
-                settings.general.description = agent.description || '';
-                settings.general.slug = agent.name.toLowerCase().replace(/\s+/g, '-').replace(/[^a-z0-9-]/g, '');
-                settings.general.icon = 'bot';
                 settings.resourceLimits.quotas = [
                     { label: 'Conversations', current: Object.values(useAgentChatStore.getState().conversations).filter(c => c.agentId === entityId).length, limit: 1000, unit: 'convs' },
                 ];
                 // Real owner
-                const ownerName = authUser?.display_name || authUser?.username || 'You';
-                const ownerEmail = authUser?.email || '';
                 settings.access = {
-                    owner: { id: 'self', name: ownerName, email: ownerEmail, role: 'owner', joinedAt: settings.general.createdAt },
-                    members: [{ id: 'self', name: ownerName, email: ownerEmail, role: 'owner', joinedAt: settings.general.createdAt }],
+                    owner: null,
+                    members: [],
                     pendingInvites: [],
                     publicAccess: false,
                     allowGuestViewing: false,
                 };
-                if (settings.defaultAgentConfig) {
-                    settings.defaultAgentConfig.defaultModel = agent.model || 'claude-sonnet-4-6';
-                    settings.defaultAgentConfig.systemInstructions = agent.systemPrompt || '';
-                    settings.defaultAgentConfig.enabledTools = agent.tools || ['web-search', 'code-execution', 'file-read'];
-                }
                 settings.resourceLimits.rateLimitRpm = agent.rateLimits?.requestsPerMinute ?? settings.resourceLimits.rateLimitRpm;
                 settings.resourceLimits.rateLimitTpd = agent.rateLimits?.tokensPerDay ?? settings.resourceLimits.rateLimitTpd;
             }
         }
-        set({ settings, isLoading: false, activeSection: 'general', isDirty: false });
+        selectedHierarchyBaseline = projectHierarchySettings(settings, wsStore.workspaces);
+        if (selectedHierarchyBaseline) {
+            const { identity: _identity, ...projection } = selectedHierarchyBaseline;
+            Object.assign(settings, projection);
+        }
+        const draft = selectedHierarchyBaseline && currentProfileDrafts().get(selectedHierarchyBaseline.identity);
+        if (draft)
+            settings.general = { ...settings.general, ...draft.fields };
+        set({ settings, isLoading: false, activeSection: 'general', isDirty: Boolean(draft),
+            profileDraftPending: Boolean(draft), profileDraftError: draft ? validateProfileDraft(settings.general) : undefined });
         // Async: load real data for IPC-backed sections
-        loadAsyncSectionData(entityId, entityType);
+        void loadAsyncSectionData(settings, generation);
     },
     setActiveSection: (section) => set({ activeSection: section }),
-    clearSettings: () => set({ settings: null, activeSection: 'general', isDirty: false }),
+    clearSettings: () => {
+        selectedHierarchyBaseline = undefined;
+        set(state => ({ settings: null, activeSection: 'general', isDirty: false,
+            profileDraftPending: false, profileDraftError: undefined,
+            loadGeneration: state.loadGeneration + 1, sectionErrors: {}, sectionLoading: {}, backupBusy: false }));
+    },
     updateGeneral: (updates) => {
         const { settings } = get();
-        if (!settings)
+        const identity = selectedHierarchyBaseline?.identity;
+        if (!settings || !identity)
+            return;
+        const fields = {
+            ...(updates.name !== undefined ? { name: updates.name } : {}),
+            ...(updates.description !== undefined ? { description: updates.description } : {}),
+        };
+        if (!Object.keys(fields).length)
             return;
+        const drafts = currentProfileDrafts();
+        const previous = drafts.get(identity);
+        const draft = { fields: { ...previous?.fields, ...fields }, submitted: { ...previous?.submitted } };
+        drafts.set(identity, draft);
+        const general = { ...settings.general, ...draft.fields };
+        const error = validateProfileDraft(general);
         set({
-            settings: { ...settings, general: { ...settings.general, ...updates, updatedAt: new Date().toISOString() } },
-            isDirty: true,
+            settings: { ...settings, general }, isDirty: true, profileDraftPending: true, profileDraftError: error,
         });
-        // Persist to workspace store
-        const ws = useWorkspaceStore.getState();
-        if (settings.entityType === 'workspace') {
-            ws.updateWorkspace(settings.entityId, {
-                name: updates.name || settings.general.name,
-                description: updates.description ?? settings.general.description,
-            });
-        }
-        else if (settings.entityType === 'team' && settings.workspaceId) {
-            ws.updateTeam(settings.workspaceId, settings.entityId, {
-                name: updates.name || settings.general.name,
-                description: updates.description ?? settings.general.description,
-            });
+        if (!error)
+            void persistProfileFields(settings, identity, drafts, draft.fields);
+    },
+    discardProfileChanges: async () => {
+        const state = get(), identity = selectedHierarchyBaseline?.identity;
+        if (!state.settings || !identity)
+            return false;
+        const drafts = currentProfileDrafts(), draft = drafts.get(identity);
+        if (!draft)
+            return true;
+        try {
+            const loaded = await getAgentPlatformBridge().workspaceStorage.load();
+            if (!loaded.success || !Array.isArray(loaded.workspaces))
+                throw new Error('Acknowledged profile is unavailable; draft retained.');
+            const incoming = projectHierarchySettings(state.settings, loaded.workspaces);
+            if (!incoming || incoming.identity !== identity)
+                throw new Error('The original profile no longer exists; draft retained.');
+            if (selectedHierarchyBaseline?.identity !== identity || drafts.get(identity) !== draft)
+                return false;
+            // Submitted edits may still exist in the optimistic hierarchy. Revert only
+            // those profile fields through its existing CAS path, never reset the tree.
+            if (Object.keys(draft.submitted).length) {
+                const revert = Object.fromEntries(Object.keys(draft.submitted).map(key => [key, incoming.general[key]]));
+                draft.fields = revert;
+                if (!await persistProfileFields(state.settings, identity, drafts, revert))
+                    return false;
+            }
+            if (selectedHierarchyBaseline?.identity !== identity || (drafts.has(identity) && drafts.get(identity) !== draft))
+                return false;
+            drafts.delete(identity);
+            selectedHierarchyBaseline = incoming;
+            const current = get();
+            if (current.settings && projectHierarchySettings(current.settings, loaded.workspaces)?.identity === identity) {
+                set({ settings: { ...current.settings, general: { ...current.settings.general, name: incoming.general.name, description: incoming.general.description, slug: incoming.general.slug } }, profileDraftPending: false, profileDraftError: undefined });
+            }
+            return true;
         }
-        else if (settings.entityType === 'agent' && settings.workspaceId && settings.teamId) {
-            ws.updateAgent(settings.workspaceId, settings.teamId, settings.entityId, {
-                name: updates.name || settings.general.name,
-                description: updates.description ?? settings.general.description,
-            });
+        catch (error) {
+            if (selectedHierarchyBaseline?.identity === identity)
+                set({ profileDraftError: error instanceof Error ? error.message : 'Profile discard failed; draft retained.' });
+            return false;
         }
     },
     updateDefaultAgentConfig: (updates) => {
@@ -499,6 +551,21 @@ export const useEntitySettingsStore = create((set, get) => ({
             settings: { ...settings, defaultAgentConfig: { ...settings.defaultAgentConfig, ...updates } },
             isDirty: true,
         });
+        const workspace = useWorkspaceStore.getState().workspaces.find(w => w.id === (settings.workspaceId || settings.entityId));
+        const existing = settings.entityType === 'workspace' ? workspace?.agentDefaults
+            : workspace?.teams.find(t => t.id === settings.entityId)?.agentDefaults;
+        const defaults = {
+            ...existing,
+            ...(updates.defaultModel !== undefined ? { model: updates.defaultModel } : {}),
+            ...(updates.systemInstructions !== undefined ? { systemPrompt: updates.systemInstructions } : {}),
+            ...(updates.enabledTools !== undefined ? { tools: [...updates.enabledTools] } : {}),
+        };
+        if (settings.entityType === 'workspace') {
+            useWorkspaceStore.getState().updateWorkspace(settings.entityId, { agentDefaults: defaults });
+        }
+        else if (settings.entityType === 'team' && settings.workspaceId) {
+            useWorkspaceStore.getState().updateTeam(settings.workspaceId, settings.entityId, { agentDefaults: defaults });
+        }
         // Persist to workspace store — for agents, update model/prompt/tools
         if (settings.entityType === 'agent' && settings.workspaceId && settings.teamId) {
             const agentUpdates = {};
@@ -512,22 +579,7 @@ export const useEntitySettingsStore = create((set, get) => ({
         }
     },
     updateAccess: (updates) => {
-        const { settings } = get();
-        if (!settings)
-            return;
-        set({
-            settings: { ...settings, access: { ...settings.access, ...updates } },
-            isDirty: true,
-        });
-        // Persist access settings to workspace store
-        if (settings.entityType === 'workspace') {
-            useWorkspaceStore.getState().updateWorkspace(settings.entityId, {
-                access: {
-                    publicAccess: updates.publicAccess ?? settings.access.publicAccess,
-                    allowGuestViewing: updates.allowGuestViewing ?? settings.access.allowGuestViewing,
-                },
-            });
-        }
+        set(state => ({ sectionErrors: { ...state.sectionErrors, access: 'Workspace sharing is not connected to an access-control authority. Access was not changed.' } }));
     },
     updateResourceLimits: (updates) => {
         const { settings } = get();
@@ -577,155 +629,55 @@ export const useEntitySettingsStore = create((set, get) => ({
         }
     },
     updateSecurity: (updates) => {
-        const { settings } = get();
-        if (!settings)
-            return;
-        const merged = { ...settings.security, ...updates };
-        set({
-            settings: { ...settings, security: merged },
-            isDirty: true,
-        });
-        // Persist security settings to workspace store
-        if (settings.entityType === 'workspace') {
-            useWorkspaceStore.getState().updateWorkspace(settings.entityId, {
-                security: {
-                    require2FA: merged.require2FA,
-                    requireApiKeyAuth: merged.requireApiKeyAuth,
-                    sessionTimeout: merged.sessionTimeout,
-                    ipAllowlist: [...merged.ipAllowlist],
-                },
-            });
-        }
+        set(state => ({ sectionErrors: { ...state.sectionErrors, security: 'Workspace authentication policy is not connected to an enforcement authority. Security settings were not changed.' } }));
     },
-    updateExportBackup: (updates) => {
-        const { settings } = get();
-        if (!settings)
-            return;
-        set({
-            settings: { ...settings, exportBackup: { ...settings.exportBackup, ...updates } },
-            isDirty: true,
-        });
-        // Persist backup settings
-        getAgentPlatformBridge()?.exportBackup?.updateSettings?.({
+    updateExportBackup: (updates) => runBackupOperation(async (api, settings) => {
+        const policy = {
             autoBackupEnabled: updates.autoBackupEnabled ?? settings.exportBackup.autoBackupEnabled,
             frequency: updates.backupFrequency ?? settings.exportBackup.backupFrequency,
             retentionDays: updates.retentionDays ?? settings.exportBackup.retentionDays,
-        }).catch(() => { });
-    },
+        };
+        if (!Number.isInteger(policy.retentionDays) || policy.retentionDays < 7 || policy.retentionDays > 90) {
+            throw new Error('Backup retention must be an integer between 7 and 90 days.');
+        }
+        const result = await api.updateSettings({ ...backupScope(settings), ...policy });
+        requireSuccess(result, 'Backup policy update');
+        return { autoBackupEnabled: policy.autoBackupEnabled, backupFrequency: policy.frequency, retentionDays: policy.retentionDays };
+    }),
     addMember: (member) => {
-        const { settings } = get();
-        if (!settings)
-            return;
-        const newMember = { ...member, id: `user_${generateId()}`, joinedAt: new Date().toISOString() };
-        set({
-            settings: { ...settings, access: { ...settings.access, members: [...settings.access.members, newMember] } },
-            isDirty: true,
-        });
+        set(state => ({ sectionErrors: { ...state.sectionErrors, access: 'Member invitations require a connected workspace membership authority. No invitation was sent.' } }));
     },
     removeMember: (memberId) => {
-        const { settings } = get();
-        if (!settings)
-            return;
-        set({
-            settings: {
-                ...settings,
-                access: { ...settings.access, members: settings.access.members.filter(m => m.id !== memberId) },
-            },
-            isDirty: true,
-        });
+        set(state => ({ sectionErrors: { ...state.sectionErrors, access: 'Member removal requires a connected workspace membership authority. Membership was not changed.' } }));
     },
     updateMemberRole: (memberId, role) => {
-        const { settings } = get();
-        if (!settings)
-            return;
-        set({
-            settings: {
-                ...settings,
-                access: {
-                    ...settings.access,
-                    members: settings.access.members.map(m => m.id === memberId ? { ...m, role } : m),
-                },
-            },
-            isDirty: true,
-        });
+        set(state => ({ sectionErrors: { ...state.sectionErrors, access: 'Role changes require a connected workspace membership authority. Permissions were not changed.' } }));
     },
     addIntegration: (integration) => {
-        const { settings } = get();
-        if (!settings)
-            return;
-        const newInt = { ...integration, id: `int_${generateId()}` };
-        set({
-            settings: {
-                ...settings,
-                integrations: { ...settings.integrations, integrations: [...settings.integrations.integrations, newInt] },
-            },
-            isDirty: true,
-        });
+        set(state => ({ sectionErrors: { ...state.sectionErrors, integrations: 'Integration authorization is not connected on this surface. No service was connected.' } }));
     },
     removeIntegration: (integrationId) => {
-        const { settings } = get();
-        if (!settings)
-            return;
-        set({
-            settings: {
-                ...settings,
-                integrations: {
-                    ...settings.integrations,
-                    integrations: settings.integrations.integrations.filter(i => i.id !== integrationId),
-                },
-            },
-            isDirty: true,
-        });
+        set(state => ({ sectionErrors: { ...state.sectionErrors, integrations: 'Integration revocation is not connected on this surface. No service was disconnected.' } }));
     },
     toggleIntegration: (integrationId) => {
-        const { settings } = get();
-        if (!settings)
-            return;
-        set({
-            settings: {
-                ...settings,
-                integrations: {
-                    ...settings.integrations,
-                    integrations: settings.integrations.integrations.map(i => i.id === integrationId ? { ...i, enabled: !i.enabled, status: !i.enabled ? 'connected' : 'disconnected' } : i),
-                },
-            },
-            isDirty: true,
-        });
+        set(state => ({ sectionErrors: { ...state.sectionErrors, integrations: 'Integration authorization is not connected on this surface. Connection status was not changed.' } }));
     },
     addEnvironmentVariable: (variable) => {
-        const { settings } = get();
-        if (!settings)
-            return;
-        const newVar = { ...variable, id: `env_${generateId()}`, updatedAt: new Date().toISOString() };
-        const nextVars = [...settings.environment.variables, newVar];
-        set({
-            settings: { ...settings, environment: { variables: nextVars } },
-            isDirty: true,
-        });
-        syncEnvVarsToWorkspaceStore(settings, nextVars);
+        return changeEnvironment({ action: 'set', key: variable.key, value: variable.value, isSecret: variable.isSecret });
     },
     updateEnvironmentVariable: (variableId, updates) => {
         const { settings } = get();
         if (!settings)
-            return;
-        const nextVars = settings.environment.variables.map(v => v.id === variableId ? { ...v, ...updates, updatedAt: new Date().toISOString() } : v);
-        set({
-            settings: { ...settings, environment: { variables: nextVars } },
-            isDirty: true,
-        });
-        syncEnvVarsToWorkspaceStore(settings, nextVars);
+            return Promise.resolve(false);
+        const current = settings.environment.variables.find(variable => variable.id === variableId);
+        if (!current || updates.value === undefined)
+            return Promise.resolve(false);
+        return changeEnvironment({ action: 'set', key: current.key, value: updates.value, isSecret: updates.isSecret ?? current.isSecret });
     },
     deleteEnvironmentVariable: (variableId) => {
-        const { settings } = get();
-        if (!settings)
-            return;
-        const nextVars = settings.environment.variables.filter(v => v.id !== variableId);
-        set({
-            settings: { ...settings, environment: { variables: nextVars } },
-            isDirty: true,
-        });
-        syncEnvVarsToWorkspaceStore(settings, nextVars);
+        return changeEnvironment({ action: 'delete', key: variableId });
     },
+    migrateEnvironmentVariables: () => changeEnvironment({ action: 'migrate' }),
     addNotificationRule: (rule) => {
         const { settings } = get();
         if (!settings)
@@ -761,156 +713,177 @@ export const useEntitySettingsStore = create((set, get) => ({
         syncNotificationsToWorkspaceStore(settings, { ...settings.notifications, rules: nextRules });
     },
     addApiKey: (key) => {
-        const { settings } = get();
-        if (!settings)
-            return;
-        const now = new Date().toISOString();
-        const newKey = { ...key, id: `key_${generateId()}`, createdAt: now, lastUsed: now };
-        set({
-            settings: {
-                ...settings,
-                integrations: { ...settings.integrations, apiKeys: [...settings.integrations.apiKeys, newKey] },
-            },
-            isDirty: true,
-        });
+        set(state => ({ sectionErrors: { ...state.sectionErrors, integrations: 'Workspace API-key issuance is not connected on this surface. No API key was created.' } }));
     },
     removeApiKey: (keyId) => {
-        const { settings } = get();
-        if (!settings)
-            return;
-        set({
-            settings: {
-                ...settings,
-                integrations: { ...settings.integrations, apiKeys: settings.integrations.apiKeys.filter(k => k.id !== keyId) },
-            },
-            isDirty: true,
-        });
+        set(state => ({ sectionErrors: { ...state.sectionErrors, integrations: 'Workspace API-key revocation is not connected on this surface. No API key was revoked.' } }));
     },
     addWebhook: (webhook) => {
-        const { settings } = get();
-        if (!settings)
-            return;
-        const newWh = { ...webhook, id: `wh_${generateId()}`, createdAt: new Date().toISOString() };
-        set({
-            settings: {
-                ...settings,
-                integrations: { ...settings.integrations, webhookEndpoints: [...settings.integrations.webhookEndpoints, newWh] },
-            },
-            isDirty: true,
-        });
+        set(state => ({ sectionErrors: { ...state.sectionErrors, integrations: 'Webhook delivery is not connected on this surface. No webhook was registered.' } }));
     },
     removeWebhook: (webhookId) => {
-        const { settings } = get();
-        if (!settings)
-            return;
-        set({
-            settings: {
-                ...settings,
-                integrations: {
-                    ...settings.integrations,
-                    webhookEndpoints: settings.integrations.webhookEndpoints.filter(w => w.id !== webhookId),
-                },
-            },
-            isDirty: true,
-        });
+        set(state => ({ sectionErrors: { ...state.sectionErrors, integrations: 'Webhook delivery is not connected on this surface. No webhook was removed.' } }));
     },
     toggleWebhook: (webhookId) => {
-        const { settings } = get();
-        if (!settings)
-            return;
-        set({
-            settings: {
-                ...settings,
-                integrations: {
-                    ...settings.integrations,
-                    webhookEndpoints: settings.integrations.webhookEndpoints.map(w => w.id === webhookId ? { ...w, enabled: !w.enabled } : w),
-                },
-            },
-            isDirty: true,
-        });
-    },
-    createBackup: async (name) => {
-        const { settings } = get();
-        if (!settings)
-            return;
-        const result = await getAgentPlatformBridge()?.exportBackup?.createBackup?.(name);
-        if (result?.success && result.backup) {
-            const backup = result.backup;
-            const newBackup = {
-                id: backup.id || `backup_${Date.now()}`,
-                name: backup.name || name || 'Backup',
-                size: formatBytes(backup.size || 0),
-                createdAt: backup.createdAt || new Date().toISOString(),
-                type: 'manual',
-            };
-            set({
-                settings: {
-                    ...settings,
-                    exportBackup: {
-                        ...settings.exportBackup,
-                        availableBackups: [newBackup, ...settings.exportBackup.availableBackups],
-                    },
-                },
-            });
-        }
-    },
-    deleteBackup: async (backupId) => {
-        const { settings } = get();
-        if (!settings)
-            return;
-        await getAgentPlatformBridge()?.exportBackup?.deleteBackup?.(backupId);
-        set({
-            settings: {
-                ...settings,
-                exportBackup: {
-                    ...settings.exportBackup,
-                    availableBackups: settings.exportBackup.availableBackups.filter(b => b.id !== backupId),
-                },
-            },
-        });
+        set(state => ({ sectionErrors: { ...state.sectionErrors, integrations: 'Webhook delivery is not connected on this surface. Delivery status was not changed.' } }));
     },
-    archiveEntity: () => {
-        const { settings } = get();
-        if (!settings)
-            return;
-        const ws = useWorkspaceStore.getState();
-        if (settings.entityType === 'workspace') {
-            ws.archiveWorkspace(settings.entityId);
+    createBackup: (name) => runBackupOperation(async (api, settings) => {
+        const result = await api.createBackup({ ...backupScope(settings), name });
+        requireSuccess(result, 'Backup creation');
+        const backup = result.backup;
+        if (!backup?.id || !backup.createdAt || typeof backup.size !== 'number') {
+            throw new Error('The host did not return a valid created backup.');
         }
-    },
+        return { availableBackups: [{
+                    id: backup.id, name: backup.name || name, size: formatBytes(backup.size),
+                    createdAt: backup.createdAt, type: 'manual',
+                }, ...settings.exportBackup.availableBackups] };
+    }),
+    deleteBackup: (id) => runBackupOperation(async (api, settings) => {
+        const result = await api.deleteBackup({ ...backupScope(settings), id });
+        requireSuccess(result, 'Backup deletion');
+        return { availableBackups: settings.exportBackup.availableBackups.filter(backup => backup.id !== id) };
+    }),
+    downloadBackup: (id) => runBackupOperation(async (api, settings) => {
+        requireSuccess(await api.downloadBackup({ ...backupScope(settings), id }), 'Backup download');
+    }),
+    restoreBackup: (id) => runBackupOperation(async (api, settings) => {
+        const result = await api.importBackup({ ...backupScope(settings), id });
+        requireSuccess(result, 'Backup restore');
+        set({ backupRestoreResult: result.restoredConversations ?? [] });
+        await useWorkspaceStore.getState().loadWorkspaces();
+        await loadLocalAgentConversations();
+    }),
+    exportData: (format) => runBackupOperation(async (api, settings) => {
+        requireSuccess(await (format === 'json' ? api.exportJson(backupScope(settings)) : api.exportCsv(backupScope(settings))), 'Workspace export');
+    }),
+    archiveEntity: () => applyEntityLifecycle('archive'),
     transferOwnership: (newOwnerId) => {
-        const { settings } = get();
-        if (!settings)
-            return;
-        const newOwner = settings.access.members.find(m => m.id === newOwnerId);
-        if (!newOwner)
-            return;
-        set({
-            settings: {
-                ...settings,
-                access: {
-                    ...settings.access,
-                    owner: { ...newOwner, role: 'owner' },
-                    members: settings.access.members.map(m => m.id === newOwnerId ? { ...m, role: 'owner' } : m.id === settings.access.owner.id ? { ...m, role: 'admin' } : m),
-                },
-            },
-            isDirty: true,
-        });
+        set(state => ({ sectionErrors: { ...state.sectionErrors, access: 'Ownership transfer requires a connected workspace membership authority. Ownership was not changed.' } }));
     },
-    deleteEntity: () => {
-        const { settings } = get();
-        if (!settings)
-            return;
-        const ws = useWorkspaceStore.getState();
-        if (settings.entityType === 'workspace') {
-            ws.deleteWorkspace(settings.entityId);
+    deleteEntity: () => applyEntityLifecycle('delete'),
+}));
+async function persistProfileFields(settings, identity, drafts, fields) {
+    const sent = { ...fields };
+    const draft = drafts.get(identity);
+    if (!draft)
+        return false;
+    draft.submitted = { ...draft.submitted, ...sent };
+    const workspace = useWorkspaceStore.getState();
+    if (settings.entityType === 'workspace')
+        workspace.updateWorkspace(settings.entityId, sent);
+    else if (settings.entityType === 'team' && settings.workspaceId)
+        workspace.updateTeam(settings.workspaceId, settings.entityId, sent);
+    else if (settings.entityType === 'agent' && settings.workspaceId && settings.teamId)
+        workspace.updateAgent(settings.workspaceId, settings.teamId, settings.entityId, sent);
+    else
+        return false;
+    try {
+        await requireWorkspacePersistence(workspaces => {
+            const current = projectHierarchySettings(settings, workspaces);
+            return current?.identity === identity && Object.entries(sent).every(([key, value]) => current.general[key] === value);
+        });
+        const currentDraft = drafts.get(identity);
+        if (currentDraft) {
+            for (const key of Object.keys(sent)) {
+                if (currentDraft.fields[key] === sent[key])
+                    delete currentDraft.fields[key];
+                if (currentDraft.submitted[key] === sent[key])
+                    delete currentDraft.submitted[key];
+            }
+            if (!Object.keys(currentDraft.fields).length)
+                drafts.delete(identity);
         }
-        else if (settings.entityType === 'team' && settings.workspaceId) {
-            ws.deleteTeam(settings.workspaceId, settings.entityId);
+        if (selectedHierarchyBaseline?.identity === identity) {
+            const remaining = drafts.get(identity);
+            useEntitySettingsStore.setState({ profileDraftPending: Boolean(remaining), profileDraftError: remaining && useEntitySettingsStore.getState().settings ? validateProfileDraft(useEntitySettingsStore.getState().settings.general) : undefined });
         }
-        else if (settings.entityType === 'agent' && settings.workspaceId && settings.teamId) {
-            ws.deleteAgent(settings.workspaceId, settings.teamId, settings.entityId);
+        return true;
+    }
+    catch (error) {
+        if (selectedHierarchyBaseline?.identity === identity && drafts.has(identity))
+            useEntitySettingsStore.setState({ profileDraftError: error instanceof Error ? error.message : 'Profile save was not acknowledged.' });
+        return false;
+    }
+}
+let hierarchyRefreshGeneration = 0;
+useWorkspaceStore.subscribe((next, previous) => {
+    if (next.workspaces === previous.workspaces && next.persistenceStatus === previous.persistenceStatus)
+        return;
+    const refresh = ++hierarchyRefreshGeneration;
+    const loadGeneration = useEntitySettingsStore.getState().loadGeneration;
+    if (!selectedHierarchyBaseline && !currentProfileDrafts().size)
+        return;
+    // Workspace mutations enqueue persistence inside Zustand updates. Start after
+    // that enqueue, then inspect the host ACK rather than accepting optimistic data.
+    queueMicrotask(() => { void reconcileAcknowledgedHierarchy(refresh, loadGeneration); });
+});
+async function reconcileAcknowledgedHierarchy(refresh, loadGeneration) {
+    let acknowledged;
+    try {
+        await requireWorkspacePersistence(workspaces => {
+            // The persistence guard checks acknowledged state first, then optimistic
+            // state. Capture only the former; a pending/conflicted edit is not authority.
+            acknowledged ??= workspaces;
+            return true;
+        });
+    }
+    catch {
+        return;
+    } // WorkspaceStore retains the actionable persistence error.
+    if (refresh === hierarchyRefreshGeneration && acknowledged) {
+        for (const identity of currentProfileDrafts().keys()) {
+            if (!profileIdentityExists(identity, acknowledged))
+                currentProfileDrafts().delete(identity);
         }
-    },
-}));
+    }
+    const state = useEntitySettingsStore.getState();
+    const baseline = selectedHierarchyBaseline;
+    if (refresh !== hierarchyRefreshGeneration || loadGeneration !== state.loadGeneration || !state.settings || !baseline || !acknowledged)
+        return;
+    const incoming = projectHierarchySettings(state.settings, acknowledged);
+    if (!incoming || incoming.identity !== baseline.identity) {
+        currentProfileDrafts().delete(baseline.identity);
+        state.clearSettings();
+        return;
+    }
+    if (JSON.stringify(incoming) === JSON.stringify(baseline))
+        return;
+    selectedHierarchyBaseline = incoming;
+    useEntitySettingsStore.setState({ settings: {
+            ...state.settings,
+            entityName: incoming.entityName, workspaceName: incoming.workspaceName,
+            ...(incoming.teamName !== undefined ? { teamName: incoming.teamName } : {}),
+            general: mergeAcknowledgedFields(state.settings.general, baseline.general, incoming.general),
+            ...(state.settings.defaultAgentConfig && baseline.defaultAgentConfig && incoming.defaultAgentConfig ? {
+                defaultAgentConfig: mergeAcknowledgedFields(state.settings.defaultAgentConfig, baseline.defaultAgentConfig, incoming.defaultAgentConfig),
+            } : {}),
+        } });
+}
+async function applyEntityLifecycle(action) {
+    const initial = useEntitySettingsStore.getState();
+    const settings = initial.settings;
+    if (!settings || initial.sectionLoading.dangerZone)
+        return false;
+    const generation = initial.loadGeneration;
+    const current = () => useEntitySettingsStore.getState().loadGeneration === generation;
+    useEntitySettingsStore.setState(state => ({ sectionLoading: { ...state.sectionLoading, dangerZone: true }, sectionErrors: { ...state.sectionErrors, dangerZone: undefined } }));
+    try {
+        const scope = { workspaceId: settings.entityType === 'workspace' ? settings.entityId : settings.workspaceId,
+            ...(settings.entityType === 'team' ? { teamId: settings.entityId } : settings.teamId ? { teamId: settings.teamId } : {}),
+            ...(settings.entityType === 'agent' ? { agentId: settings.entityId } : {}) };
+        if (!await requestWorkspaceLifecycle(scope, action))
+            throw new Error(useWorkspaceStore.getState().lifecycleError || 'Lifecycle was not confirmed');
+        return current();
+    }
+    catch (error) {
+        if (current())
+            useEntitySettingsStore.setState(state => ({ sectionErrors: { ...state.sectionErrors, dangerZone: settingsError(error) } }));
+        return false;
+    }
+    finally {
+        if (current())
+            useEntitySettingsStore.setState(state => ({ sectionLoading: { ...state.sectionLoading, dangerZone: false } }));
+    }
+}
 //# sourceMappingURL=entitySettingsStore.js.map