codexmate 0.0.53 → 0.0.55

package/web-ui/app.js

@@ -79,6 +79,8 @@ document.addEventListener('DOMContentLoaded', () => {
                 projectPathOptionsLoading: false,
                 showSkillsModal: false,
                 showHealthCheckModal: false,
+                showProviderCacheModal: false,
+                showProviderCacheAnnouncementModal: false,
                 showCodexBridgePoolModal: false,
                 showClaudeBridgePoolModal: false,
                 showWebhookModal: false,
@@ -378,6 +380,14 @@ document.addEventListener('DOMContentLoaded', () => {
                 codexDownloadLoading: false,
                 codexDownloadProgress: 0,
                 codexDownloadTimer: null,
+                providerCacheRecords: { root: '', generatedAt: '', groups: [] },
+                providerCacheLoadedOnce: false,
+                providerCacheLoadedAt: '',
+                providerCacheLoading: false,
+                providerCacheSyncing: false,
+                providerCacheSyncMessage: '',
+                providerCacheError: '',
+                providerCacheRequestSeq: 0,
                 settingsTab: 'general',
                 toolConfigPermissions: (function() {
                     try {
@@ -506,6 +516,18 @@ document.addEventListener('DOMContentLoaded', () => {
             if (typeof this.loadWebhookSettings === 'function') {
                 this.loadWebhookSettings();
             }
+            if (typeof this.loadWebUiPreferences === 'function') {
+                const applyPreferenceNavigation = (() => {
+                    try {
+                        const url = new URL(window.location.href);
+                        if (url.pathname === '/session') return false;
+                        return !String(url.searchParams.get('tab') || '').trim();
+                    } catch (_) {
+                        return true;
+                    }
+                })();
+                void this.loadWebUiPreferences({ applyNavigation: applyPreferenceNavigation });
+            }
             if (typeof this.t === 'function') {
                 this.confirmDialogConfirmText = this.t('confirm.ok');
                 this.confirmDialogCancelText = this.t('confirm.cancel');
@@ -693,8 +715,14 @@ document.addEventListener('DOMContentLoaded', () => {
                     if (typeof this.loadAppVersionStatus === 'function') {
                         void this.loadAppVersionStatus({ silent: true });
                     }
+                    if (typeof this.hydrateClaudeConfigsFromProviderCache === 'function') {
+                        await this.hydrateClaudeConfigsFromProviderCache({ silent: true });
+                    }
                     void this.refreshClaudeSelectionFromSettings({ silent: true });
                     void this.syncDefaultOpenclawConfigEntry({ silent: true });
+                    if (typeof this.loadProviderCacheRecords === 'function') {
+                        void this.loadProviderCacheRecords({ background: true });
+                    }
                 };
                 if (typeof requestAnimationFrame === 'function') {
                     this._initialLoadRafId = requestAnimationFrame(() => {
@@ -743,6 +771,10 @@ document.addEventListener('DOMContentLoaded', () => {
                 clearTimeout(this._initialLoadTimer);
                 this._initialLoadTimer = 0;
             }
+            if (this.__webUiPreferencesPersistTimer) {
+                clearTimeout(this.__webUiPreferencesPersistTimer);
+                this.__webUiPreferencesPersistTimer = 0;
+            }
             window.removeEventListener('resize', this.onWindowResize);
             window.removeEventListener('keydown', this.handleGlobalKeydown);
             window.removeEventListener('beforeunload', this.handleBeforeUnload);
@@ -767,6 +799,9 @@ document.addEventListener('DOMContentLoaded', () => {
                 try {
                     localStorage.setItem('codexmate_prompts_sub_tab', newVal);
                 } catch (_) {}
+                if (typeof this.persistWebUiPreferences === 'function') {
+                    this.persistWebUiPreferences({ promptsSubTab: newVal });
+                }
                 if (this.mainTab === 'prompts' && typeof this.loadPromptsContent === 'function') {
                     this.loadPromptsContent();
                 }
@@ -779,6 +814,9 @@ document.addEventListener('DOMContentLoaded', () => {
                         localStorage.removeItem('codexmate_project_claude_md_path');
                     }
                 } catch (_) {}
+                if (typeof this.persistWebUiPreferences === 'function') {
+                    this.persistWebUiPreferences({ projectClaudeMdPath: newPath || '' });
+                }
             }
         },
 

package/web-ui/logic.claude.mjs

@@ -191,6 +191,14 @@ export function matchClaudeConfigFromSettings(claudeConfigs = {}, env = {}) {
         if (normalizedSettings.apiKey && normalizedConfig.apiKey === normalizedSettings.apiKey) {
             return name;
         }
+        if (normalizedSettings.apiKey
+            && normalizedConfig.apiKey === ''
+            && config
+            && typeof config.providerCacheRef === 'string'
+            && config.providerCacheRef.trim()
+            && config.hasKey === true) {
+            return name;
+        }
         if (!normalizedSettings.apiKey
             && normalizedConfig.apiKey === ''
             && normalizedConfig.externalCredentialType

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

@@ -20,6 +20,7 @@ function getClaudeConfigValidationForContext(vm, mode = 'add') {
     const draft = mode === 'edit' ? vm.editingConfig : vm.newClaudeConfig;
     const name = normalizeClaudeText(draft && draft.name);
     const apiKey = normalizeClaudeText(draft && draft.apiKey);
+    const providerCacheRef = normalizeClaudeText(draft && draft.providerCacheRef);
     const externalCredentialType = normalizeClaudeText(draft && draft.externalCredentialType);
     const baseUrl = normalizeClaudeBaseUrl(draft && draft.baseUrl);
     const model = normalizeClaudeText(draft && draft.model);
@@ -40,7 +41,7 @@ function getClaudeConfigValidationForContext(vm, mode = 'add') {
         errors.name = vm.t('validation.claude.nameExists');
     }
 
-    if (!apiKey && !externalCredentialType && targetApi !== 'ollama') {
+    if (!apiKey && !externalCredentialType && !providerCacheRef && targetApi !== 'ollama') {
         errors.apiKey = vm.t('validation.claude.apiKeyRequired');
     }
 
@@ -58,6 +59,7 @@ function getClaudeConfigValidationForContext(vm, mode = 'add') {
         mode,
         name,
         apiKey,
+        providerCacheRef,
         externalCredentialType,
         baseUrl,
         model,
@@ -112,6 +114,64 @@ export function createClaudeConfigMethods(options = {}) {
             this.syncClaudeBridgeProviders();
         },
 
+        async hydrateClaudeConfigsFromProviderCache(options = {}) {
+            const silent = options && options.silent === true;
+            try {
+                const res = await api('get-claude-provider-cache-configs');
+                if (!res || res.error) {
+                    if (!silent) this.showMessage((res && res.error) || this.t('toast.claude.loadSettingsFail'), 'error');
+                    return false;
+                }
+                const providers = Array.isArray(res.providers) ? res.providers : [];
+                if (providers.length === 0) return true;
+                const configs = this.claudeConfigs && typeof this.claudeConfigs === 'object' ? this.claudeConfigs : {};
+                let changed = false;
+                let firstCachedName = '';
+                for (const provider of providers) {
+                    if (!provider || typeof provider !== 'object') continue;
+                    const name = normalizeClaudeText(provider.name);
+                    const baseUrl = normalizeClaudeBaseUrl(provider.baseUrl);
+                    const model = normalizeClaudeText(provider.model);
+                    if (!name || !baseUrl || !model) continue;
+                    if (!firstCachedName) firstCachedName = name;
+                    const cachedConfig = {
+                        apiKey: '',
+                        baseUrl,
+                        model,
+                        hasKey: provider.hasKey === true,
+                        providerCacheRef: normalizeClaudeText(provider.providerCacheRef) || name,
+                        source: 'provider-cache',
+                        targetApi: normalizeClaudeText(provider.targetApi) || 'responses'
+                    };
+                    const existing = configs[name];
+                    if (existing && existing.source !== 'provider-cache' && existing.providerCacheRef !== cachedConfig.providerCacheRef) {
+                        continue;
+                    }
+                    if (JSON.stringify(existing || {}) !== JSON.stringify(cachedConfig)) {
+                        configs[name] = cachedConfig;
+                        changed = true;
+                    }
+                }
+                this.claudeConfigs = configs;
+                if (firstCachedName) {
+                    let savedCurrent = '';
+                    try { savedCurrent = localStorage.getItem('currentClaudeConfig') || ''; } catch (_) {}
+                    const current = normalizeClaudeText(this.currentClaudeConfig);
+                    const currentConfig = current && configs[current] ? configs[current] : null;
+                    if (!savedCurrent && (!current || (currentConfig && currentConfig.hasKey === false && !currentConfig.providerCacheRef))) {
+                        this.currentClaudeConfig = firstCachedName;
+                        try { localStorage.setItem('currentClaudeConfig', firstCachedName); } catch (_) {}
+                        changed = true;
+                    }
+                }
+                if (changed) this.saveClaudeConfigs();
+                return true;
+            } catch (e) {
+                if (!silent) this.showMessage(e && e.message ? e.message : this.t('toast.claude.loadSettingsFail'), 'error');
+                return false;
+            }
+        },
+
         async syncClaudeBridgeProviders() {
             try { await api('claude-local-bridge-sync-providers', { providers: this.claudeConfigs || {} }); } catch (_) {}
         },
@@ -154,6 +214,7 @@ export function createClaudeConfigMethods(options = {}) {
                 model: config.model || '',
                 targetApi: config.targetApi || 'responses'
             };
+            if (config.providerCacheRef) this.editingConfig.providerCacheRef = config.providerCacheRef;
             this.showEditClaudeConfigKey = false;
             this.showEditConfigModal = true;
         },
@@ -165,6 +226,8 @@ export function createClaudeConfigMethods(options = {}) {
             }
             const name = validation.name;
             this.editingConfig.apiKey = validation.apiKey;
+            if (validation.providerCacheRef) this.editingConfig.providerCacheRef = validation.providerCacheRef;
+            else delete this.editingConfig.providerCacheRef;
             this.editingConfig.externalCredentialType = validation.externalCredentialType;
             this.editingConfig.baseUrl = validation.baseUrl;
             this.editingConfig.model = validation.model;
@@ -195,6 +258,8 @@ export function createClaudeConfigMethods(options = {}) {
             }
             const name = validation.name;
             this.editingConfig.apiKey = validation.apiKey;
+            if (validation.providerCacheRef) this.editingConfig.providerCacheRef = validation.providerCacheRef;
+            else delete this.editingConfig.providerCacheRef;
             this.editingConfig.externalCredentialType = validation.externalCredentialType;
             this.editingConfig.baseUrl = validation.baseUrl;
             this.editingConfig.model = validation.model;
@@ -203,7 +268,7 @@ export function createClaudeConfigMethods(options = {}) {
             this.saveClaudeConfigs();
 
             const config = this.claudeConfigs[name];
-            if (!config.apiKey && config.targetApi !== 'ollama') {
+            if (!config.apiKey && !config.providerCacheRef && config.targetApi !== 'ollama') {
                 this.showMessage(this.t('toast.claude.savedWithoutKey'), 'info');
                 this.closeEditConfigModal();
                 if (name === this.currentClaudeConfig) {
@@ -212,7 +277,7 @@ export function createClaudeConfigMethods(options = {}) {
                 return;
             }
 
-            const _claudeKey = `${name}|${config.apiKey || ""}|${config.baseUrl || ""}|${config.model || ""}|${config.targetApi || "responses"}`;
+            const _claudeKey = `${name}|${config.apiKey || ""}|${config.providerCacheRef || ""}|${config.baseUrl || ""}|${config.model || ""}|${config.targetApi || "responses"}`;
             try {
                 const res = await api('apply-claude-config', { config: { ...config, name } });
                 if (res.error || res.success === false) {
@@ -238,6 +303,8 @@ export function createClaudeConfigMethods(options = {}) {
             }
             this.newClaudeConfig.name = validation.name;
             this.newClaudeConfig.apiKey = validation.apiKey;
+            if (validation.providerCacheRef) this.newClaudeConfig.providerCacheRef = validation.providerCacheRef;
+            else delete this.newClaudeConfig.providerCacheRef;
             this.newClaudeConfig.externalCredentialType = validation.externalCredentialType;
             this.newClaudeConfig.baseUrl = validation.baseUrl;
             this.newClaudeConfig.model = validation.model;
@@ -284,14 +351,14 @@ export function createClaudeConfigMethods(options = {}) {
             this.refreshClaudeModelContext();
             const config = this.claudeConfigs[name];
 
-            if (!config.apiKey && config.targetApi !== 'ollama') {
+            if (!config.apiKey && !config.providerCacheRef && config.targetApi !== 'ollama') {
                 if (config.externalCredentialType) {
                     return this.showMessage(this.t('toast.claude.externalAuth'), 'info');
                 }
                 return this.showMessage(this.t('toast.claude.apiKeyRequired'), 'error');
             }
 
-            const _claudeKey2 = `${name}|${config.apiKey || ""}|${config.baseUrl || ""}|${config.model || ""}|${config.targetApi || "responses"}`;
+            const _claudeKey2 = `${name}|${config.apiKey || ""}|${config.providerCacheRef || ""}|${config.baseUrl || ""}|${config.model || ""}|${config.targetApi || "responses"}`;
             try {
                 const res = await api('apply-claude-config', { config: { ...config, name } });
                 if (res.error || res.success === false) {

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

@@ -21,6 +21,7 @@ import { createOpenclawEditingMethods } from './app.methods.openclaw-editing.mjs
 import { createOpenclawPersistMethods } from './app.methods.openclaw-persist.mjs';
 import { createOpencodeConfigMethods } from './app.methods.opencode-config.mjs';
 import { createProvidersMethods } from './app.methods.providers.mjs';
+import { createProviderCacheMethods } from './app.methods.provider-cache.mjs';
 import { createRuntimeMethods } from './app.methods.runtime.mjs';
 import { createToolConfigPermissionMethods } from './app.methods.tool-config-permissions.mjs';
 import { createTaskOrchestrationMethods } from './app.methods.task-orchestration.mjs';
@@ -33,6 +34,7 @@ import { createSkillsMethods } from './skills.methods.mjs';
 import { createPluginsMethods } from './plugins.methods.mjs';
 import { createI18nMethods } from './i18n.mjs';
 import { createWebhookMethods } from './app.methods.webhook.mjs';
+import { createWebUiPreferencesMethods } from './app.methods.web-ui-preferences.mjs';
 import {
     CONFIG_MODE_SET,
     getProviderConfigModeMeta
@@ -83,6 +85,8 @@ export function createAppMethods() {
         ...createPluginsMethods(),
         ...createAgentsMethods({ api, apiWithMeta }),
         ...createProvidersMethods({ api }),
+        ...createProviderCacheMethods({ api }),
+        ...createWebUiPreferencesMethods({ api }),
         ...createClaudeConfigMethods({ api }),
         ...createToolConfigPermissionMethods({ api }),
         ...createOpenclawCoreMethods(),

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

@@ -108,6 +108,9 @@
         try {
             localStorage.setItem(NAV_STATE_STORAGE_KEY, JSON.stringify(snapshot));
         } catch (_) {}
+        if (typeof vm.persistWebUiPreferences === 'function') {
+            vm.persistWebUiPreferences({ navigation: snapshot });
+        }
     };
 
     return {

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.session-actions.mjs

@@ -281,6 +281,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 +292,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 +317,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

@@ -260,17 +260,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 +465,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 +477,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 +529,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) {