codexmate 0.0.54 → 0.0.56

package/web-ui/modules/app.methods.provider-cache.mjs

@@ -0,0 +1,223 @@
+export function createProviderCacheMethods(options = {}) {
+    const { api } = options;
+
+    return {
+        async openProviderCacheModal(options = {}) {
+            this.showProviderCacheModal = true;
+            if (options.forceRefresh === true || !this.providerCacheLoadedOnce) {
+                await this.loadProviderCacheRecords({ forceRefresh: options.forceRefresh === true });
+            }
+        },
+
+        closeProviderCacheModal() {
+            this.showProviderCacheModal = false;
+        },
+
+        async openProviderCacheAnnouncementModal() {
+            this.showProviderCacheAnnouncementModal = true;
+            if (!this.providerCacheLoadedOnce) {
+                await this.loadProviderCacheRecords();
+            }
+        },
+
+        closeProviderCacheAnnouncementModal() {
+            this.showProviderCacheAnnouncementModal = false;
+        },
+
+        async openProviderCacheDetailsFromAnnouncement() {
+            this.showProviderCacheAnnouncementModal = false;
+            await this.openProviderCacheModal({ forceRefresh: false });
+        },
+
+        async loadProviderCacheRecords(options = {}) {
+            const forceRefresh = options && options.forceRefresh === true;
+            const background = options && options.background === true;
+            if (this.providerCacheLoading && !forceRefresh) return;
+            const requestSeq = (Number(this.providerCacheRequestSeq) || 0) + 1;
+            this.providerCacheRequestSeq = requestSeq;
+            const isLatestRequest = () => requestSeq === Number(this.providerCacheRequestSeq || 0);
+            if (!background) {
+                this.providerCacheLoading = true;
+            }
+            this.providerCacheError = '';
+            try {
+                const res = await api('get-provider-cache-records');
+                if (!isLatestRequest()) return;
+                if (res && res.error) {
+                    this.providerCacheError = res.error;
+                    return;
+                }
+                this.providerCacheRecords = res && typeof res === 'object' ? res : { groups: [] };
+                this.providerCacheLoadedOnce = true;
+                this.providerCacheLoadedAt = this.providerCacheRecords.generatedAt || new Date().toISOString();
+            } catch (e) {
+                if (!isLatestRequest()) return;
+                this.providerCacheError = e && e.message ? e.message : this.t('modal.providerCache.loadFailed');
+            } finally {
+                if (isLatestRequest() && !background) {
+                    this.providerCacheLoading = false;
+                }
+            }
+        },
+
+        async syncProviderCacheRecords() {
+            if (this.providerCacheSyncing) return;
+            this.providerCacheSyncing = true;
+            this.providerCacheError = '';
+            this.providerCacheSyncMessage = '';
+            try {
+                const res = await api('sync-provider-cache-records');
+                if (res && res.error) {
+                    this.providerCacheError = res.errorKey ? this.t(res.errorKey) : res.error;
+                    return;
+                }
+                const summary = res && res.summary && typeof res.summary === 'object' ? res.summary : {};
+                const providerCount = Number(summary.providerCount || 0);
+                const fileCount = Number(summary.fileCount || 0);
+                this.providerCacheSyncMessage = this.t('modal.providerCache.syncSucceeded', { count: providerCount, fileCount });
+                if (res && res.records && typeof res.records === 'object') {
+                    this.providerCacheRecords = res.records;
+                    this.providerCacheLoadedOnce = true;
+                    this.providerCacheLoadedAt = this.providerCacheRecords.generatedAt || new Date().toISOString();
+                }
+                await this.loadProviderCacheRecords({ forceRefresh: true });
+            } catch (e) {
+                this.providerCacheError = e && e.message ? e.message : this.t('modal.providerCache.syncFailed');
+            } finally {
+                this.providerCacheSyncing = false;
+            }
+        },
+
+        getProviderCacheGroups() {
+            const records = this.providerCacheRecords && typeof this.providerCacheRecords === 'object'
+                ? this.providerCacheRecords
+                : {};
+            return Array.isArray(records.groups) ? records.groups : [];
+        },
+
+        getProviderCacheAnnouncementSummary() {
+            const groups = this.getProviderCacheGroups();
+            let fileCount = 0;
+            let providerCount = 0;
+            for (const group of groups) {
+                const files = this.getProviderCacheExistingFiles(group);
+                fileCount += files.length;
+                for (const file of files) {
+                    const count = Number(file && file.providerCount);
+                    if (Number.isFinite(count) && count > 0) {
+                        providerCount += count;
+                    } else {
+                        providerCount += this.getProviderCacheFileProviders(file).length;
+                    }
+                }
+            }
+            return {
+                groupCount: groups.length,
+                fileCount,
+                providerCount,
+                loadedAt: this.providerCacheLoadedAt || (this.providerCacheRecords && this.providerCacheRecords.generatedAt) || ''
+            };
+        },
+
+        getProviderCacheAnnouncementGroups() {
+            return this.getProviderCacheGroups().map((group) => {
+                const existingFiles = this.getProviderCacheExistingFiles(group);
+                return {
+                    key: group && group.key ? group.key : '',
+                    label: group && group.label ? group.label : '',
+                    existingCount: existingFiles.length,
+                    providerCount: existingFiles.reduce((sum, file) => {
+                        const count = Number(file && file.providerCount);
+                        if (Number.isFinite(count) && count > 0) return sum + count;
+                        return sum + this.getProviderCacheFileProviders(file).length;
+                    }, 0)
+                };
+            });
+        },
+
+        getProviderCacheExistingFiles(group) {
+            const files = group && Array.isArray(group.files) ? group.files : [];
+            return files.filter((file) => file && file.exists);
+        },
+
+        hasProviderCacheExistingFiles(group) {
+            return this.getProviderCacheExistingFiles(group).length > 0;
+        },
+
+        getProviderCacheFileKey(file) {
+            if (!file) return '';
+            return file.displayPath || file.path || file.name || '';
+        },
+
+        getProviderCacheFilePath(file) {
+            if (!file) return '';
+            return file.displayPath || file.path || file.name || '';
+        },
+
+        getProviderCacheFileSummary(file) {
+            if (!file || !file.exists) return '';
+            const count = Number(file.providerCount || 0);
+            if (count > 0) return this.t('modal.providerCache.providerCount', { count });
+            if (file.tooLarge) return this.t('modal.providerCache.tooLarge');
+            if (file.ok === false) return this.t('modal.providerCache.parseFailed');
+            return this.t('modal.providerCache.rawJsonOnly');
+        },
+
+        getProviderCacheFileProviders(file) {
+            const providers = file && Array.isArray(file.providers) ? file.providers : [];
+            return providers.filter((provider) => provider && typeof provider === 'object');
+        },
+
+        hasProviderCacheProviders(file) {
+            return this.getProviderCacheFileProviders(file).length > 0;
+        },
+
+        getProviderCacheProviderMeta(provider) {
+            if (!provider || typeof provider !== 'object') return [];
+            const fields = [
+                ['baseUrl', 'base_url'],
+                ['wireApi', 'wire_api'],
+                ['authMethod', 'auth'],
+                ['model', 'model']
+            ];
+            return fields
+                .map(([key, label]) => {
+                    const value = provider[key];
+                    if (value === undefined || value === null || value === '') return null;
+                    return { label, value: String(value) };
+                })
+                .filter(Boolean);
+        },
+
+        getProviderCacheProviderText(provider) {
+            if (!provider || typeof provider !== 'object') return '';
+            try {
+                return JSON.stringify(provider.data === undefined ? provider : provider.data, null, 2);
+            } catch (_) {
+                return String(provider.name || '');
+            }
+        },
+
+        getProviderCacheRecordText(record) {
+            if (!record || !record.exists) return '';
+            if (record.ok === false) {
+                return record.error || '';
+            }
+            try {
+                return JSON.stringify(record.data === undefined ? null : record.data, null, 2);
+            } catch (_) {
+                return String(record.data || '');
+            }
+        },
+
+        formatProviderCacheFileSize(size) {
+            const bytes = Number(size);
+            if (!Number.isFinite(bytes) || bytes <= 0) return '0 B';
+            if (bytes < 1024) return `${Math.floor(bytes)} B`;
+            const kib = bytes / 1024;
+            if (kib < 1024) return `${kib.toFixed(kib >= 10 ? 0 : 1)} KiB`;
+            const mib = kib / 1024;
+            return `${mib.toFixed(mib >= 10 ? 1 : 2)} MiB`;
+        }
+    };
+}

package/web-ui/modules/app.methods.providers.mjs

@@ -1,3 +1,5 @@
+import { nextCodexProviderName } from './provider-default-names.mjs';
+
 const PROVIDER_NAME_PATTERN = /^[a-zA-Z0-9._-]+$/;
 const RESERVED_PROXY_PROVIDER_NAME = 'codexmate-proxy';
 const RESERVED_LOCAL_PROVIDER_NAME = 'local';
@@ -327,6 +329,18 @@ export function createProvidersMethods(options = {}) {
             this.showAddModal = true;
         },
 
+        openAddProviderModal() {
+            this.newProvider = {
+                name: nextCodexProviderName(this.providersList),
+                url: '',
+                key: '',
+                model: '',
+                useTransform: false
+            };
+            this.showAddProviderKey = false;
+            this.showAddModal = true;
+        },
+
         async openEditModal(provider) {
             const requestId = Symbol('openEditModal');
             this._openEditModalRequestId = requestId;
@@ -536,7 +550,7 @@ export function createProvidersMethods(options = {}) {
         closeAddModal() {
             this.showAddModal = false;
             this.showAddProviderKey = false;
-            this.newProvider = { name: '', url: '', key: '', model: '', useTransform: false };
+            this.newProvider = { name: nextCodexProviderName(this.providersList), url: '', key: '', model: '', useTransform: false };
         },
 
         toggleAddProviderKey() {

package/web-ui/modules/app.methods.runtime.mjs

@@ -154,6 +154,10 @@ export function createRuntimeMethods(options = {}) {
             const baseUrl = config && typeof config.baseUrl === 'string' ? config.baseUrl.trim() : '';
             const apiKey = config && typeof config.apiKey === 'string' ? config.apiKey.trim() : '';
             const model = config && typeof config.model === 'string' ? config.model.trim() : '';
+            const targetApiRaw = config && typeof config.targetApi === 'string' ? config.targetApi.trim().toLowerCase() : '';
+            const targetApi = targetApiRaw === 'ollama'
+                ? 'ollama'
+                : (targetApiRaw === 'chat_completions' || targetApiRaw === 'chat-completions' || targetApiRaw === 'chat/completions' ? 'chat_completions' : 'responses');
             this.claudeSpeedLoading[name] = true;
             try {
                 if (!baseUrl) {
@@ -161,7 +165,7 @@ export function createRuntimeMethods(options = {}) {
                     this.claudeSpeedResults[name] = res;
                     return res;
                 }
-                if (!apiKey) {
+                if (!apiKey && targetApi !== 'ollama') {
                     const res = { ok: false, error: 'Missing API key' };
                     this.claudeSpeedResults[name] = res;
                     return res;
@@ -175,7 +179,8 @@ export function createRuntimeMethods(options = {}) {
                     kind: 'claude',
                     url: baseUrl,
                     apiKey,
-                    model
+                    model,
+                    targetApi
                 });
                 if (res.error) {
                     this.claudeSpeedResults[name] = { ok: false, error: res.error };

package/web-ui/modules/app.methods.session-actions.mjs

@@ -165,6 +165,30 @@ export function createSessionActionMethods(options = {}) {
             this.showMessage(this.t('toast.copy.fail'), 'error');
         },
 
+        async copySessionWorkspaceBrief() {
+            const summary = this.activeSessionWorkspaceSummary;
+            const text = summary && typeof summary.briefText === 'string'
+                ? summary.briefText.trim()
+                : '';
+            if (!text) {
+                this.showMessage(this.t('sessions.workspace.copy.empty'), 'error');
+                return;
+            }
+            const ok = this.fallbackCopyText(text);
+            if (ok) {
+                this.showMessage(this.t('sessions.workspace.copy.success'), 'success');
+                return;
+            }
+            try {
+                if (navigator.clipboard && window.isSecureContext) {
+                    await navigator.clipboard.writeText(text);
+                    this.showMessage(this.t('sessions.workspace.copy.success'), 'success');
+                    return;
+                }
+            } catch (_) {}
+            this.showMessage(this.t('toast.copy.fail'), 'error');
+        },
+
         getSessionExportKey(session) {
             return `${session.source || 'unknown'}:${session.sessionId || ''}:${session.filePath || ''}`;
         },
@@ -281,6 +305,9 @@ export function createSessionActionMethods(options = {}) {
             try {
                 localStorage.setItem('codexmateSessionTrashEnabled', enabled ? 'true' : 'false');
             } catch (_) {}
+            if (typeof this.persistWebUiPreferences === 'function') {
+                this.persistWebUiPreferences({ sessionTrashEnabled: enabled });
+            }
         },
 
         setSessionTimelineStyle(style) {
@@ -289,12 +316,18 @@ export function createSessionActionMethods(options = {}) {
             try {
                 localStorage.setItem('codexmateSessionTimelineStyle', normalized);
             } catch (_) {}
+            if (typeof this.persistWebUiPreferences === 'function') {
+                this.persistWebUiPreferences({ sessionTimelineStyle: normalized });
+            }
         },
 
         setConfigTemplateDiffConfirmEnabled(value) {
             const enabled = this.normalizeConfigTemplateDiffConfirmEnabled(value);
             this.configTemplateDiffConfirmEnabled = enabled;
             persistConfigTemplateDiffConfirmEnabledToStorage(enabled);
+            if (typeof this.persistWebUiPreferences === 'function') {
+                this.persistWebUiPreferences({ configTemplateDiffConfirmEnabled: enabled });
+            }
         },
 
         getShareCommandPrefixInvocation() {
@@ -308,6 +341,9 @@ export function createSessionActionMethods(options = {}) {
             try {
                 localStorage.setItem('codexmateShareCommandPrefix', normalized);
             } catch (_) {}
+            if (typeof this.persistWebUiPreferences === 'function') {
+                this.persistWebUiPreferences({ shareCommandPrefix: normalized });
+            }
         },
 
         fallbackCopyText(text) {

package/web-ui/modules/app.methods.session-browser.mjs

@@ -803,6 +803,9 @@ export function createSessionBrowserMethods(options = {}) {
             const range = normalized === 'all' ? 'all' : (normalized === '30d' ? '30d' : '7d');
             this.sessionsUsageTimeRange = range;
             try { localStorage.setItem('sessionsUsageTimeRange', range); } catch (_) {}
+            if (typeof this.persistWebUiPreferences === 'function') {
+                this.persistWebUiPreferences({ sessionsUsageTimeRange: range });
+            }
             if (range === 'all') {
                 this.sessionsUsageCompareEnabled = false;
             }

package/web-ui/modules/app.methods.session-trash.mjs

@@ -311,6 +311,9 @@ export function createSessionTrashMethods(options = {}) {
             const normalized = this.normalizeSessionTrashRetentionDays(days);
             this.sessionTrashRetentionDays = normalized;
             try { localStorage.setItem('codexmateSessionTrashRetentionDays', String(normalized)); } catch (_) {}
+            if (typeof this.persistWebUiPreferences === 'function') {
+                this.persistWebUiPreferences({ sessionTrashRetentionDays: normalized });
+            }
         },
 
         getSessionTrashActionKey(item) {

package/web-ui/modules/app.methods.startup-claude.mjs

@@ -8,6 +8,31 @@ import {
     normalizeClaudeSettingsEnv,
     normalizeClaudeValue
 } from '../logic.mjs';
+import { nextClaudeConfigName } from './provider-default-names.mjs';
+
+const DELETED_CLAUDE_SETTINGS_IMPORTS_STORAGE_KEY = 'deletedClaudeSettingsImports';
+
+function normalizeDeletedClaudeImportUrl(value) {
+    return typeof value === 'string' ? value.trim().replace(/\/+$/g, '') : '';
+}
+
+function shouldSuppressDeletedClaudeSettingsImport(env = {}) {
+    const normalized = normalizeClaudeSettingsEnv(env);
+    const baseUrl = normalizeDeletedClaudeImportUrl(normalized.baseUrl);
+    const model = normalizeClaudeValue(normalized.model);
+    if (!baseUrl || !model) return false;
+    try {
+        const raw = localStorage.getItem(DELETED_CLAUDE_SETTINGS_IMPORTS_STORAGE_KEY);
+        const parsed = raw ? JSON.parse(raw) : [];
+        const entries = Array.isArray(parsed) ? parsed : [];
+        return entries.some((entry) => entry
+            && typeof entry === 'object'
+            && normalizeDeletedClaudeImportUrl(entry.baseUrl) === baseUrl
+            && normalizeClaudeValue(entry.model) === model);
+    } catch (_) {
+        return false;
+    }
+}
 
 export function createStartupClaudeMethods(options = {}) {
     const {
@@ -250,7 +275,7 @@ export function createStartupClaudeMethods(options = {}) {
         },
 
         shouldSuppressClaudeSettingsImport(env) {
-            return isLikelyBuiltinClaudeProxySettingsEnv(env);
+            return isLikelyBuiltinClaudeProxySettingsEnv(env) || shouldSuppressDeletedClaudeSettingsImport(env);
         },
 
         findDuplicateClaudeConfigName(config) {
@@ -260,17 +285,23 @@ export function createStartupClaudeMethods(options = {}) {
         mergeClaudeConfig(existing = {}, updates = {}) {
             const previous = this.normalizeClaudeConfig(existing);
             const next = this.normalizeClaudeConfig({ ...existing, ...updates });
+            const raw = { ...existing, ...updates };
+            const providerCacheRef = typeof raw.providerCacheRef === 'string' ? raw.providerCacheRef.trim() : '';
+            const source = raw.source === 'provider-cache' ? 'provider-cache' : (existing.source === 'provider-cache' && providerCacheRef ? 'provider-cache' : '');
             const externalCredentialType = next.apiKey
                 ? ''
                 : (next.externalCredentialType || previous.externalCredentialType || '');
-            return {
+            const merged = {
                 apiKey: next.apiKey,
                 baseUrl: next.baseUrl,
                 model: next.model || previous.model || 'glm-4.7',
-                hasKey: !!(next.apiKey || externalCredentialType),
+                hasKey: !!(next.apiKey || externalCredentialType || providerCacheRef || raw.hasKey === true),
                 externalCredentialType,
                 targetApi: next.targetApi || previous.targetApi || 'responses'
             };
+            if (providerCacheRef) merged.providerCacheRef = providerCacheRef;
+            if (source) merged.source = source;
+            return merged;
         },
 
         buildClaudeImportedConfigName(baseUrl) {
@@ -459,6 +490,9 @@ export function createStartupClaudeMethods(options = {}) {
             const currentConfigName = typeof this.currentClaudeConfig === 'string' ? this.currentClaudeConfig.trim() : '';
             const baseUrl = (config.baseUrl || '').trim();
             const apiKey = (config.apiKey || '').trim();
+            const providerCacheRef = typeof config.providerCacheRef === 'string'
+                ? config.providerCacheRef.trim()
+                : '';
             const externalCredentialType = typeof config.externalCredentialType === 'string'
                 ? config.externalCredentialType.trim()
                 : '';
@@ -468,7 +502,7 @@ export function createStartupClaudeMethods(options = {}) {
                 return;
             }
             const localCatalog = getClaudeModelCatalogForBaseUrl(baseUrl);
-            if (!apiKey && externalCredentialType) {
+            if (!apiKey && (externalCredentialType || providerCacheRef)) {
                 this.claudeModels = localCatalog;
                 this.claudeModelsSource = localCatalog.length ? 'catalog' : 'unlimited';
                 if (localCatalog.length) {
@@ -520,6 +554,7 @@ export function createStartupClaudeMethods(options = {}) {
                 }
                 return (latestConfig.baseUrl || '').trim() === baseUrl
                     && (latestConfig.apiKey || '').trim() === apiKey
+                    && (typeof latestConfig.providerCacheRef === 'string' ? latestConfig.providerCacheRef.trim() : '') === providerCacheRef
                     && (typeof latestConfig.externalCredentialType === 'string' ? latestConfig.externalCredentialType.trim() : '') === externalCredentialType;
             };
             if (cachedOk) {
@@ -563,6 +598,14 @@ export function createStartupClaudeMethods(options = {}) {
         },
 
         openClaudeConfigModal() {
+            this.newClaudeConfig = {
+                name: nextClaudeConfigName(this.claudeConfigs),
+                apiKey: '',
+                externalCredentialType: '',
+                baseUrl: '',
+                model: '',
+                targetApi: 'responses'
+            };
             this.showAddClaudeConfigKey = false;
             this.showClaudeConfigModal = true;
         },

package/web-ui/modules/app.methods.web-ui-preferences.mjs

@@ -0,0 +1,161 @@
+export function createWebUiPreferencesMethods(options = {}) {
+    const api = typeof options.api === 'function' ? options.api : async () => ({});
+    const storageOverride = options.storage && typeof options.storage === 'object' ? options.storage : null;
+
+    const getLocalStorage = () => {
+        const storage = storageOverride || (typeof globalThis !== 'undefined' ? globalThis.localStorage : null);
+        return storage && typeof storage.setItem === 'function' && typeof storage.removeItem === 'function'
+            ? storage
+            : null;
+    };
+
+    const setLocalStorageValue = (key, value) => {
+        const storage = getLocalStorage();
+        if (!storage) return;
+        try {
+            if (value === null || value === undefined || value === '') {
+                storage.removeItem(key);
+            } else {
+                storage.setItem(key, String(value));
+            }
+        } catch (_) {}
+    };
+
+    const normalizeUsageTimeRange = (value) => {
+        const normalized = typeof value === 'string' ? value.trim().toLowerCase() : '';
+        if (normalized === 'all' || normalized === '30d') return normalized;
+        return '7d';
+    };
+
+    const normalizePromptsSubTab = (value) => {
+        const normalized = typeof value === 'string' ? value.trim().toLowerCase() : '';
+        return normalized === 'claude-project' ? 'claude-project' : 'codex';
+    };
+
+    const normalizeNavigationSnapshot = (vm, source = {}) => {
+        const currentSkillsTargetApp = vm.skillsTargetApp === 'claude' ? 'claude' : 'codex';
+        const currentPromptTemplatesMode = vm.promptTemplatesMode === 'manage' ? 'manage' : 'compose';
+        return {
+            mainTab: typeof source.mainTab === 'string' ? source.mainTab : vm.mainTab,
+            configMode: typeof source.configMode === 'string' ? source.configMode : vm.configMode,
+            settingsTab: typeof source.settingsTab === 'string' ? source.settingsTab : vm.settingsTab,
+            skillsTargetApp: source.skillsTargetApp === 'claude' || source.skillsTargetApp === 'codex'
+                ? source.skillsTargetApp
+                : currentSkillsTargetApp,
+            promptTemplatesMode: source.promptTemplatesMode === 'manage' || source.promptTemplatesMode === 'compose'
+                ? source.promptTemplatesMode
+                : currentPromptTemplatesMode
+        };
+    };
+
+    return {
+        buildWebUiPreferencesSnapshot(overrides = {}) {
+            const navigationOverride = overrides && typeof overrides.navigation === 'object' && overrides.navigation
+                ? overrides.navigation
+                : null;
+            return {
+                shareCommandPrefix: typeof this.normalizeShareCommandPrefix === 'function'
+                    ? this.normalizeShareCommandPrefix(overrides.shareCommandPrefix || this.shareCommandPrefix)
+                    : (this.shareCommandPrefix || 'npm start'),
+                sessionTrashEnabled: typeof this.normalizeSessionTrashEnabled === 'function'
+                    ? this.normalizeSessionTrashEnabled(Object.prototype.hasOwnProperty.call(overrides, 'sessionTrashEnabled') ? overrides.sessionTrashEnabled : this.sessionTrashEnabled)
+                    : this.sessionTrashEnabled !== false,
+                sessionTrashRetentionDays: typeof this.normalizeSessionTrashRetentionDays === 'function'
+                    ? this.normalizeSessionTrashRetentionDays(Object.prototype.hasOwnProperty.call(overrides, 'sessionTrashRetentionDays') ? overrides.sessionTrashRetentionDays : this.sessionTrashRetentionDays)
+                    : 30,
+                sessionTimelineStyle: typeof this.normalizeSessionTimelineStyle === 'function'
+                    ? this.normalizeSessionTimelineStyle(overrides.sessionTimelineStyle || this.sessionTimelineStyle)
+                    : (this.sessionTimelineStyle === 'bar' ? 'bar' : 'dots'),
+                configTemplateDiffConfirmEnabled: typeof this.normalizeConfigTemplateDiffConfirmEnabled === 'function'
+                    ? this.normalizeConfigTemplateDiffConfirmEnabled(Object.prototype.hasOwnProperty.call(overrides, 'configTemplateDiffConfirmEnabled') ? overrides.configTemplateDiffConfirmEnabled : this.configTemplateDiffConfirmEnabled)
+                    : this.configTemplateDiffConfirmEnabled !== false,
+                sessionsUsageTimeRange: normalizeUsageTimeRange(overrides.sessionsUsageTimeRange || this.sessionsUsageTimeRange),
+                promptsSubTab: normalizePromptsSubTab(overrides.promptsSubTab || this.promptsSubTab),
+                projectClaudeMdPath: typeof overrides.projectClaudeMdPath === 'string'
+                    ? overrides.projectClaudeMdPath
+                    : (typeof this.projectClaudeMdPath === 'string' ? this.projectClaudeMdPath : ''),
+                navigation: normalizeNavigationSnapshot(this, navigationOverride || {})
+            };
+        },
+
+        applyWebUiPreferences(preferences = {}, options = {}) {
+            const source = preferences && typeof preferences === 'object' ? preferences : {};
+            const shouldApplyNavigation = !(options && options.applyNavigation === false);
+            this.__webUiPreferencesApplying = true;
+            try {
+                if (typeof source.shareCommandPrefix === 'string' && typeof this.normalizeShareCommandPrefix === 'function') {
+                    this.shareCommandPrefix = this.normalizeShareCommandPrefix(source.shareCommandPrefix);
+                    setLocalStorageValue('codexmateShareCommandPrefix', this.shareCommandPrefix);
+                }
+                if (Object.prototype.hasOwnProperty.call(source, 'sessionTrashEnabled') && typeof this.normalizeSessionTrashEnabled === 'function') {
+                    this.sessionTrashEnabled = this.normalizeSessionTrashEnabled(source.sessionTrashEnabled);
+                    setLocalStorageValue('codexmateSessionTrashEnabled', this.sessionTrashEnabled ? 'true' : 'false');
+                }
+                if (Object.prototype.hasOwnProperty.call(source, 'sessionTrashRetentionDays') && typeof this.normalizeSessionTrashRetentionDays === 'function') {
+                    this.sessionTrashRetentionDays = this.normalizeSessionTrashRetentionDays(source.sessionTrashRetentionDays);
+                    setLocalStorageValue('codexmateSessionTrashRetentionDays', this.sessionTrashRetentionDays);
+                }
+                if (typeof source.sessionTimelineStyle === 'string' && typeof this.normalizeSessionTimelineStyle === 'function') {
+                    this.sessionTimelineStyle = this.normalizeSessionTimelineStyle(source.sessionTimelineStyle);
+                    setLocalStorageValue('codexmateSessionTimelineStyle', this.sessionTimelineStyle);
+                }
+                if (Object.prototype.hasOwnProperty.call(source, 'configTemplateDiffConfirmEnabled') && typeof this.normalizeConfigTemplateDiffConfirmEnabled === 'function') {
+                    this.configTemplateDiffConfirmEnabled = this.normalizeConfigTemplateDiffConfirmEnabled(source.configTemplateDiffConfirmEnabled);
+                    setLocalStorageValue('codexmateConfigTemplateDiffConfirmEnabled', this.configTemplateDiffConfirmEnabled ? 'true' : 'false');
+                }
+                if (typeof source.sessionsUsageTimeRange === 'string') {
+                    this.sessionsUsageTimeRange = normalizeUsageTimeRange(source.sessionsUsageTimeRange);
+                    setLocalStorageValue('sessionsUsageTimeRange', this.sessionsUsageTimeRange);
+                }
+                if (typeof source.promptsSubTab === 'string') {
+                    this.promptsSubTab = normalizePromptsSubTab(source.promptsSubTab);
+                    setLocalStorageValue('codexmate_prompts_sub_tab', this.promptsSubTab);
+                }
+                if (typeof source.projectClaudeMdPath === 'string') {
+                    this.projectClaudeMdPath = source.projectClaudeMdPath;
+                    setLocalStorageValue('codexmate_project_claude_md_path', this.projectClaudeMdPath);
+                }
+                if (shouldApplyNavigation && source.navigation && typeof source.navigation === 'object') {
+                    const nav = source.navigation;
+                    if (typeof nav.settingsTab === 'string' && typeof this.normalizeSettingsTab === 'function') {
+                        this.settingsTab = this.normalizeSettingsTab(nav.settingsTab);
+                    }
+                    if (typeof nav.configMode === 'string') this.configMode = nav.configMode;
+                    if (typeof nav.mainTab === 'string') {
+                        if (typeof this.switchMainTab === 'function') {
+                            this.switchMainTab(nav.mainTab);
+                        } else {
+                            this.mainTab = nav.mainTab;
+                        }
+                    }
+                    if (nav.skillsTargetApp === 'codex' || nav.skillsTargetApp === 'claude') this.skillsTargetApp = nav.skillsTargetApp;
+                    if (nav.promptTemplatesMode === 'compose' || nav.promptTemplatesMode === 'manage') this.promptTemplatesMode = nav.promptTemplatesMode;
+                    if (typeof this.saveNavState === 'function') this.saveNavState();
+                }
+            } finally {
+                this.__webUiPreferencesApplying = false;
+            }
+        },
+
+        async loadWebUiPreferences(options = {}) {
+            try {
+                const res = await api('get-web-ui-preferences');
+                if (res && res.preferences && typeof res.preferences === 'object') {
+                    this.applyWebUiPreferences(res.preferences, options && typeof options === 'object' ? options : {});
+                }
+            } catch (_) {}
+        },
+
+        persistWebUiPreferences(overrides = {}) {
+            if (this.__webUiPreferencesApplying) return;
+            const snapshot = this.buildWebUiPreferencesSnapshot(overrides && typeof overrides === 'object' ? overrides : {});
+            if (this.__webUiPreferencesPersistTimer) {
+                clearTimeout(this.__webUiPreferencesPersistTimer);
+            }
+            this.__webUiPreferencesPersistTimer = setTimeout(() => {
+                this.__webUiPreferencesPersistTimer = 0;
+                api('set-web-ui-preferences', { preferences: snapshot }).catch(() => {});
+            }, 120);
+        }
+    };
+}