codexmate 0.0.55 → 0.0.56

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

@@ -24,6 +24,28 @@ function getResponseMessage(response, fallback) {
     return fallback;
 }
 
+
+function normalizeProviderName(value) {
+    return typeof value === 'string' ? value.trim() : '';
+}
+
+function providerIssueDetail(issues) {
+    if (!Array.isArray(issues) || !issues.length) return '';
+    return issues
+        .map((issue) => issue && (issue.message || issue.code || ''))
+        .filter(Boolean)
+        .join('；');
+}
+
+function remoteProviderDetail(remote) {
+    if (!remote || typeof remote !== 'object') return '';
+    const parts = [];
+    if (remote.endpoint) parts.push(remote.endpoint);
+    if (remote.statusCode) parts.push(String(remote.statusCode));
+    if (remote.message) parts.push(remote.message);
+    return parts.join(' · ');
+}
+
 export function createCodexConfigMethods(options = {}) {
     const {
         api,
@@ -303,6 +325,7 @@ export function createCodexConfigMethods(options = {}) {
         async runHealthCheck(options = {}) {
             this.healthCheckLoading = true;
             this.healthCheckResult = null;
+            this.healthCheckFailedProviderSelections = {};
             this.healthCheckBatchTotal = 0;
             this.healthCheckBatchDone = 0;
             this.healthCheckBatchFailed = 0;
@@ -354,7 +377,13 @@ export function createCodexConfigMethods(options = {}) {
                 }
 
                 if (this.configMode === 'claude') {
-                    const entries = Object.entries(this.claudeConfigs || {});
+                    const configs = this.claudeConfigs || {};
+                    const currentName = typeof this.currentClaudeConfig === 'string' && configs[this.currentClaudeConfig]
+                        ? this.currentClaudeConfig
+                        : Object.keys(configs)[0];
+                    const entries = currentName && configs[currentName]
+                        ? [[currentName, configs[currentName]]]
+                        : [];
                     this.healthCheckBatchTotal = entries.length;
 
                     const speedTasks = entries.map(([name, config]) => this.runClaudeSpeedTest(name, config)
@@ -395,80 +424,44 @@ export function createCodexConfigMethods(options = {}) {
                             speedTests: results
                         }
                     };
+                    if (!silent) {
+                        this.showHealthCheckModal = true;
+                    }
                     if (ok && !silent) {
-                        this.showMessage('检查通过', 'success');
+                        this.showMessage(this.t('toast.check.success'), 'success');
                     }
                     return;
                 }
 
-                const shouldRunSpeedTests = this.configMode === 'codex';
-                const speedTimeoutMs = shouldRunSpeedTests ? 3500 : 0;
-                const providers = shouldRunSpeedTests
-                    ? (this.providersList || [])
-                        .map((provider) => typeof provider === 'string'
-                            ? provider.trim()
-                            : String((provider && provider.name) || '').trim())
-                        .filter(Boolean)
-                    : [];
-                const currentProvider = String(this.currentProvider || '').trim();
-                const orderedProviders = currentProvider && providers.includes(currentProvider)
-                    ? [currentProvider, ...providers.filter((name) => name !== currentProvider)]
-                    : providers;
-                this.healthCheckBatchTotal = orderedProviders.length;
-
-                const speedTasks = orderedProviders.map((provider) => this.runSpeedTest(provider, { silent: true, timeoutMs: speedTimeoutMs })
-                    .then((result) => {
-                        if (!result || result.ok !== true) {
-                            this.healthCheckBatchFailed += 1;
-                        }
-                        return { name: provider, result };
-                    })
-                    .catch((err) => {
-                        this.healthCheckBatchFailed += 1;
-                        return {
-                            name: provider,
-                            result: { ok: false, error: err && err.message ? err.message : 'Speed test failed' }
-                        };
-                    })
-                    .finally(() => {
-                        this.healthCheckBatchDone += 1;
-                    })
-                );
-
-                const configTask = api('config-health-check', { remote: this.configMode === 'codex' });
-                const [res, pairs] = await Promise.all([
-                    configTask,
-                    Promise.all(speedTasks)
+                const [configRes, providersRes] = await Promise.all([
+                    api('config-health-check', { remote: true }),
+                    api('providers-health', { remote: false })
                 ]);
-                if (hasResponseError(res)) {
+                if (providersRes && typeof providersRes === 'object' && !hasResponseError(providersRes)) {
+                    this.providersHealthResult = providersRes;
+                }
+                if (hasResponseError(configRes)) {
                     this.healthCheckResult = null;
                     if (!silent) {
-                        this.showMessage(getResponseMessage(res, '检查失败'), 'error');
-                    }
-                } else if (res && typeof res === 'object') {
-                    const issues = Array.isArray(res.issues) ? [...res.issues] : [];
-                    let remote = res.remote || null;
-                    if (shouldRunSpeedTests) {
-                        const results = {};
-                        for (const pair of pairs) {
-                            results[pair.name] = pair.result || null;
-                            const issue = this.buildSpeedTestIssue(pair.name, pair.result);
-                            if (issue) issues.push(issue);
-                        }
-                        remote = remote && typeof remote === 'object'
-                            ? { ...remote, speedTests: results }
-                            : { type: 'speed-test', speedTests: results };
+                        this.showMessage(getResponseMessage(configRes, this.t('toast.check.fail')), 'error');
                     }
-
-                    const ok = issues.length === 0;
+                } else if (configRes && typeof configRes === 'object') {
+                    const issues = Array.isArray(configRes.issues) ? [...configRes.issues] : [];
+                    const ok = typeof configRes.ok === 'boolean' ? configRes.ok : issues.length === 0;
                     this.healthCheckResult = {
-                        ...res,
+                        ...configRes,
                         ok,
                         issues,
-                        remote
+                        remote: configRes.remote || null
                     };
-                    if (ok && !silent) {
-                        this.showMessage('检查通过', 'success');
+                    this.healthCheckBatchTotal = 1;
+                    this.healthCheckBatchDone = 1;
+                    this.healthCheckBatchFailed = ok ? 0 : 1;
+                    if (!silent) {
+                        this.showHealthCheckModal = true;
+                    }
+                    if (!silent) {
+                        this.showMessage(this.t(ok ? 'toast.check.success' : 'toast.check.fail'), ok ? 'success' : 'error');
                     }
                 } else {
                     this.healthCheckResult = null;
@@ -479,16 +472,252 @@ export function createCodexConfigMethods(options = {}) {
             } catch (e) {
                 this.healthCheckResult = null;
                 if (!(options && options.silent)) {
-                    this.showMessage('检查失败', 'error');
+                    this.showMessage(this.t('toast.check.fail'), 'error');
                 }
             } finally {
                 this.healthCheckBatchTotal = this.healthCheckBatchTotal || 0;
                 this.healthCheckBatchDone = Math.min(this.healthCheckBatchDone || 0, this.healthCheckBatchTotal || 0);
                 this.healthCheckLoading = false;
-                if (typeof this.runProvidersHealthCheck === 'function' && this.configMode === 'codex') {
-                    void this.runProvidersHealthCheck({ remote: true });
+            }
+        },
+
+        getHealthCheckFailedProviderItems() {
+            const result = this.healthCheckResult && typeof this.healthCheckResult === 'object'
+                ? this.healthCheckResult
+                : null;
+            if (!result) return [];
+            const remote = result.remote && typeof result.remote === 'object' ? result.remote : null;
+            const items = new Map();
+            const currentMode = this.configMode === 'claude' ? 'claude' : 'codex';
+            const pushItem = (name, detail, status = 'red', mode = currentMode) => {
+                const providerName = normalizeProviderName(name);
+                if (!providerName) return;
+                const key = `${mode}:${providerName}`;
+                const provider = (this.providersList || []).find((item) => item && item.name === providerName) || providerName;
+                const baseDeletable = mode === 'claude'
+                    ? !!(this.claudeConfigs && this.claudeConfigs[providerName])
+                    : (typeof this.shouldShowProviderDelete === 'function' ? this.shouldShowProviderDelete(provider) : true);
+                const writeAllowed = typeof this.isToolConfigWriteAllowed === 'function'
+                    ? this.isToolConfigWriteAllowed(mode)
+                    : true;
+                const deletable = baseDeletable && writeAllowed;
+                const blockedReason = !baseDeletable ? 'reserved' : (!writeAllowed ? 'readonly' : '');
+                const previous = items.get(key) || {};
+                items.set(key, {
+                    key,
+                    mode,
+                    name: providerName,
+                    status: previous.status || status || 'red',
+                    detail: detail || previous.detail || '',
+                    deletable,
+                    blockedReason: previous.blockedReason || blockedReason,
+                    selected: !!(this.healthCheckFailedProviderSelections && this.healthCheckFailedProviderSelections[key])
+                });
+            };
+
+            if (remote && remote.type === 'providers-health' && Array.isArray(remote.providers)) {
+                for (const provider of remote.providers) {
+                    if (!provider || provider.status === 'green') continue;
+                    pushItem(provider.provider, providerIssueDetail(provider.issues) || remoteProviderDetail(provider.remote), provider.status || 'red', 'codex');
                 }
             }
+
+            if (remote && remote.type === 'remote-health-check' && (result.ok === false || remote.ok === false)) {
+                pushItem(remote.provider, remoteProviderDetail(remote), 'red', 'codex');
+            }
+
+            if (remote && remote.speedTests && typeof remote.speedTests === 'object') {
+                for (const [name, speedResult] of Object.entries(remote.speedTests)) {
+                    if (speedResult && speedResult.ok === true) continue;
+                    pushItem(name, speedResult && speedResult.error ? speedResult.error : this.t('config.health.fail'), 'red', this.configMode === 'claude' ? 'claude' : 'codex');
+                }
+            }
+
+            if (Array.isArray(result.issues)) {
+                for (const issue of result.issues) {
+                    if (!issue || typeof issue !== 'object') continue;
+                    const name = normalizeProviderName(issue.provider || issue.providerName || issue.name);
+                    if (name) pushItem(name, issue.message || issue.code || '', 'red', currentMode);
+                }
+            }
+
+            return Array.from(items.values());
+        },
+
+        getSelectableHealthCheckFailedProviderItems() {
+            return this.getHealthCheckFailedProviderItems().filter((item) => item.deletable);
+        },
+
+        hasHealthCheckFailedProviderSelection() {
+            return this.getSelectableHealthCheckFailedProviderItems().some((item) => item.selected);
+        },
+
+        areAllHealthCheckFailedProvidersSelected() {
+            const selectable = this.getSelectableHealthCheckFailedProviderItems();
+            return selectable.length > 0 && selectable.every((item) => item.selected);
+        },
+
+        setAllHealthCheckFailedProviderSelections(checked) {
+            const selectable = this.getSelectableHealthCheckFailedProviderItems();
+            const next = { ...(this.healthCheckFailedProviderSelections || {}) };
+            for (const item of selectable) {
+                next[item.key] = !!checked;
+            }
+            this.healthCheckFailedProviderSelections = next;
+        },
+
+        toggleHealthCheckFailedProviderSelection(item, checked) {
+            if (!item || !item.key || !item.deletable) return;
+            this.healthCheckFailedProviderSelections = {
+                ...(this.healthCheckFailedProviderSelections || {}),
+                [item.key]: !!checked
+            };
+        },
+
+        async deleteSelectedHealthCheckFailedProviders() {
+            const selectedItems = this.getHealthCheckFailedProviderItems()
+                .filter((item) => item.selected && item.deletable);
+            if (!selectedItems.length) {
+                this.showMessage(this.t('toast.health.noFailedProviderSelection'), 'info');
+                return;
+            }
+            this.healthCheckFailedProviderDeleting = true;
+            const deleted = [];
+            try {
+                const claudeItems = selectedItems.filter((item) => item.mode === 'claude');
+                const codexItems = selectedItems.filter((item) => item.mode !== 'claude');
+
+                if (claudeItems.length) {
+                    const configs = this.claudeConfigs && typeof this.claudeConfigs === 'object' ? this.claudeConfigs : {};
+                    const names = claudeItems.map((item) => item.name).filter((name) => configs[name]);
+                    if (names.length) {
+                        const deletedCurrentClaude = names.includes(this.currentClaudeConfig);
+                        const remainingNames = Object.keys(configs).filter((name) => !names.includes(name));
+                        if (remainingNames.length === 0) {
+                            throw new Error(this.t('toast.claude.keepOne'));
+                        }
+                        for (const name of names) {
+                            const config = configs[name];
+                            if (config && (config.providerCacheRef || config.source === 'provider-cache')) {
+                                if (typeof this.deleteClaudeProviderCacheRef === 'function') {
+                                    const ok = await this.deleteClaudeProviderCacheRef(config);
+                                    if (!ok) throw new Error(this.t('toast.delete.fail'));
+                                } else {
+                                    const cacheName = typeof config.providerCacheRef === 'string' && config.providerCacheRef.trim()
+                                        ? config.providerCacheRef.trim()
+                                        : name;
+                                    const res = await api('delete-provider-cache-record', { name: cacheName, group: 'claude' });
+                                    if (res && res.error) throw new Error(res.error);
+                                }
+                            }
+                            if (typeof this.rememberDeletedClaudeSettingsImport === 'function') {
+                                this.rememberDeletedClaudeSettingsImport(config);
+                            }
+                            delete configs[name];
+                            deleted.push(name);
+                        }
+                        if (deletedCurrentClaude) {
+                            this.currentClaudeConfig = typeof this.selectClaudeFallbackConfigName === 'function'
+                                ? this.selectClaudeFallbackConfigName(names)
+                                : remainingNames[0];
+                        }
+                        if (typeof this.saveClaudeConfigs === 'function') {
+                            this.saveClaudeConfigs();
+                        }
+                        if (deletedCurrentClaude && typeof this.applyCurrentClaudeConfigSilently === 'function') {
+                            await this.applyCurrentClaudeConfigSilently();
+                        } else if (typeof this.refreshClaudeModelContext === 'function') {
+                            this.refreshClaudeModelContext();
+                        }
+                    }
+                }
+
+                for (const item of codexItems) {
+                    const res = await api('delete-provider', { name: item.name });
+                    if (res && res.error) {
+                        throw new Error(res.error);
+                    }
+                    this.providersList = (this.providersList || []).filter((provider) => provider && provider.name !== item.name);
+                    if (this.currentModels && this.currentModels[item.name]) {
+                        delete this.currentModels[item.name];
+                    }
+                    if (res && res.switched && res.provider) {
+                        this.currentProvider = res.provider;
+                        if (res.model) this.currentModel = res.model;
+                        this.providersList = (this.providersList || []).map((provider) => ({
+                            ...provider,
+                            current: provider.name === res.provider
+                        }));
+                    }
+                    deleted.push(item.name);
+                }
+                const deletedSet = new Set(deleted);
+                this.healthCheckFailedProviderSelections = {};
+                const result = this.healthCheckResult;
+                const remote = result && result.remote;
+                const remainingIssues = Array.isArray(result && result.issues)
+                    ? result.issues.filter((issue) => {
+                        const name = normalizeProviderName(issue && (issue.provider || issue.providerName || issue.name));
+                        return !name || !deletedSet.has(name);
+                    })
+                    : [];
+                if (result && typeof result === 'object') {
+                    if (remote && remote.type === 'providers-health' && Array.isArray(remote.providers)) {
+                        const providers = remote.providers.filter((provider) => !deletedSet.has(provider && provider.provider));
+                        const summary = {
+                            total: providers.length,
+                            green: providers.filter((p) => p && p.status === 'green').length,
+                            yellow: providers.filter((p) => p && p.status === 'yellow').length,
+                            red: providers.filter((p) => p && p.status === 'red').length
+                        };
+                        this.healthCheckResult = {
+                            ...result,
+                            ok: remainingIssues.length === 0 && summary.yellow === 0 && summary.red === 0,
+                            remote: {
+                                ...remote,
+                                providers,
+                                summary
+                            },
+                            issues: remainingIssues
+                        };
+                        this.healthCheckBatchTotal = summary.total;
+                        this.healthCheckBatchDone = summary.total;
+                        this.healthCheckBatchFailed = summary.yellow + summary.red;
+                    } else if (remote && remote.type === 'speed-test' && remote.speedTests && typeof remote.speedTests === 'object') {
+                        const speedTests = Object.fromEntries(
+                            Object.entries(remote.speedTests).filter(([name]) => !deletedSet.has(normalizeProviderName(name)))
+                        );
+                        const total = Object.keys(speedTests).length;
+                        const failed = Object.values(speedTests).filter((entry) => !entry || entry.ok !== true).length;
+                        this.healthCheckResult = {
+                            ...result,
+                            ok: remainingIssues.length === 0 && failed === 0,
+                            remote: {
+                                ...remote,
+                                speedTests
+                            },
+                            issues: remainingIssues
+                        };
+                        this.healthCheckBatchTotal = total;
+                        this.healthCheckBatchDone = total;
+                        this.healthCheckBatchFailed = failed;
+                    } else {
+                        const removedRemote = remote && remote.type === 'remote-health-check' && deletedSet.has(remote.provider);
+                        this.healthCheckResult = {
+                            ...result,
+                            ok: remainingIssues.length === 0,
+                            remote: removedRemote ? null : remote,
+                            issues: remainingIssues
+                        };
+                    }
+                }
+                this.showMessage(this.t('toast.health.deleteFailedProvidersDone', { count: deleted.length }), 'success');
+                this.showHealthCheckModal = false;
+            } catch (e) {
+                this.showMessage(e && e.message ? e.message : this.t('toast.delete.fail'), 'error');
+            } finally {
+                this.healthCheckFailedProviderDeleting = false;
+            }
         },
 
         async runProvidersHealthCheck(options = {}) {

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

@@ -724,7 +724,10 @@
                 ? this.activeSessionMessages.length
                 : 0;
             if (total <= 0) return;
-            this.sessionPreviewVisibleCount = total;
+            const initialBatchSize = Number.isFinite(this.sessionPreviewInitialBatchSize)
+                ? Math.max(1, Math.floor(this.sessionPreviewInitialBatchSize))
+                : 12;
+            this.sessionPreviewVisibleCount = Math.min(total, initialBatchSize);
             this.invalidateSessionTimelineMeasurementCache();
         },
 

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 || ''}`;
         },

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) {
@@ -573,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/i18n/locales/en.mjs

@@ -432,6 +432,8 @@ const en = Object.freeze({
     'toast.apply.fail': 'Failed to apply configuration',
     'toast.check.success': 'Check passed',
     'toast.check.fail': 'Check failed',
+    'toast.health.noFailedProviderSelection': 'Select at least one failed provider first',
+    'toast.health.deleteFailedProvidersDone': 'Deleted {count} failed provider(s)',
     'toast.noChanges': 'No changes detected',
     'toast.template.loadFail': 'Failed to load template',
     'toast.template.empty': 'Template cannot be empty',
@@ -660,6 +662,32 @@ const en = Object.freeze({
     'sessions.preview.rerender': 'Re-render',
     'sessions.preview.preparing': 'Preparing session content...',
     'sessions.preview.clipped': 'Showing the latest {count} messages only.',
+    'sessions.workspace.kicker': 'Work memory',
+    'sessions.workspace.title': 'Session reuse summary',
+    'sessions.workspace.subtitle': 'Extracted signals, commands, files, links, and risks from {count} loaded messages.',
+    'sessions.workspace.copy': 'Copy brief',
+    'sessions.workspace.copy.title': 'Session workspace brief',
+    'sessions.workspace.copy.source': 'Source',
+    'sessions.workspace.copy.path': 'Path',
+    'sessions.workspace.copy.empty': 'No session brief to copy yet',
+    'sessions.workspace.copy.success': 'Workspace brief copied',
+    'sessions.workspace.metric.messages': 'Messages',
+    'sessions.workspace.metric.user': 'User',
+    'sessions.workspace.metric.assistant': 'Assistant',
+    'sessions.workspace.metric.commands': 'Commands',
+    'sessions.workspace.metric.artifacts': 'Artifacts',
+    'sessions.workspace.metric.risks': 'Risks / todos',
+    'sessions.workspace.signals': 'Task signals',
+    'sessions.workspace.commands': 'Reusable commands',
+    'sessions.workspace.files': 'Related files',
+    'sessions.workspace.links': 'Related links',
+    'sessions.workspace.risks': 'Risks and todos',
+    'sessions.workspace.nextSteps': 'Next steps',
+    'sessions.workspace.empty': 'No strong signals yet. Continue with the raw messages below.',
+    'sessions.workspace.noneCommands': 'No command signals',
+    'sessions.workspace.noneFiles': 'No file signals',
+    'sessions.workspace.noneLinks': 'No link signals',
+    'sessions.workspace.noneRisks': 'No risks or todos detected',
     'sessions.preview.shownCount': 'Shown {shown} / {total}',
     'sessions.preview.loadMore': 'Load more (remaining {remain})',
     'sessions.preview.loadingMore': 'Loading older messages...',
@@ -895,7 +923,18 @@ const en = Object.freeze({
     'config.health.title': 'Config health check',
     'config.health.run': 'Run check',
     'config.health.running': 'Checking...',
-    'config.health.hint': 'Runs availability probes across all providers and refreshes latency badges.',
+    'config.health.hint': 'Checks only the currently selected provider; unselected providers do not count as this check\'s errors.',
+    'config.health.codexHint': 'Checks the current Codex route provider, endpoint, auth, and model through the local bridge.',
+    'config.health.providersSummary': 'Providers: {total} total · {green} ok · {yellow} config issues · {red} failed',
+    'config.health.failedProviders.title': 'Failed providers to delete',
+    'config.health.failedProviders.selectAria': 'Select failed provider {name} for deletion',
+    'config.health.failedProviders.clearSelection': 'Clear',
+    'config.health.failedProviders.selectAll': 'Select all',
+    'config.health.failedProviders.selectAllAria': 'Select all deletable failed providers',
+    'config.health.failedProviders.notDeletable': 'Reserved/system provider; cannot be deleted here.',
+    'config.health.failedProviders.writeRequired': 'Enable provider writes in this tab before deleting.',
+    'config.health.failedProviders.deleteSelected': 'Remove selected configs',
+    'config.health.failedProviders.deleting': 'Deleting...',
     'config.health.progress': '{done}/{total} done · {failed} failed',
     'config.health.ok': 'Passed',
     'config.health.fail': 'Failed',
@@ -1301,7 +1340,7 @@ const en = Object.freeze({
     'claude.health.title': 'Config health check',
     'claude.health.run': 'Run check',
     'claude.health.running': 'Checking...',
-    'claude.health.hint': 'Runs availability probes for all Claude configs and refreshes the latency badges.',
+    'claude.health.hint': 'Checks only the currently selected Claude config; unselected configs do not count as this check\'s errors.',
     'claude.health.progress': '{done}/{total} done · {failed} failed',
     'claude.md.title': 'CLAUDE.md',
     'claude.md.open': 'Open CLAUDE.md',